From a55402c9300f8d4bdcb6fd69baf211163f869c05 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 21 Apr 2019 14:32:27 -0400
Subject: [PATCH 01/55] Minor edits.

---
 Sources/DeepLearning/Tensors.swift | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/Sources/DeepLearning/Tensors.swift b/Sources/DeepLearning/Tensors.swift
index 1c1700649..ad6f758a6 100644
--- a/Sources/DeepLearning/Tensors.swift
+++ b/Sources/DeepLearning/Tensors.swift
@@ -27,18 +27,21 @@ infix operator .==: ComparisonPrecedence
 public extension Tensor {
   /// The rank of the tensor, represented as a `Tensor<Int32>`.
   @inlinable
+  @_semantics("autodiff.nonvarying")
   var rankTensor: Tensor<Int32> {
     return Raw.rank(self)
   }
 
   /// The dimensions of the tensor, represented as a `Tensor<Int32>`.
   @inlinable
+  @_semantics("autodiff.nonvarying")
   var shapeTensor: Tensor<Int32> {
     return Raw.shape(self)
   }
 
   /// The number of scalars in the tensor, represented as a `Tensor<Int32>`.
   @inlinable
+  @_semantics("autodiff.nonvarying")
   var scalarCountTensor: Tensor<Int32> {
     return Raw.size(self)
   }
@@ -53,6 +56,7 @@ extension Tensor: CustomStringConvertible {
     /// A textual representation of the tensor.
     ///
     /// - Note: use `fullDescription` for a non-pretty-printed description showing all scalars.
+    @_semantics("autodiff.nonvarying")
     public var description: String {
         return array.description
     }
@@ -69,6 +73,7 @@ public extension Tensor {
     ///     via ellipses (`...`).
     ///   - summarizing: If true, summarize description if element count exceeds twice
     ///     `edgeElementCount`.
+    @_semantics("autodiff.nonvarying")
     func description(
         lineWidth: Int = 80,
         edgeElementCount: Int = 3,
@@ -82,6 +87,7 @@ public extension Tensor {
 
     /// A full, non-pretty-printed textual representation of the tensor, showing
     /// all scalars.
+    @_semantics("autodiff.nonvarying")
     var fullDescription: String {
         return array.fullDescription
     }
@@ -89,6 +95,7 @@ public extension Tensor {
 
 // Xcode Playground display conversion.
 extension Tensor: CustomPlaygroundDisplayConvertible {
+    @_semantics("autodiff.nonvarying")
     public var playgroundDescription: Any {
         return description
     }
@@ -96,6 +103,7 @@ extension Tensor: CustomPlaygroundDisplayConvertible {
 
 // Mirror representation, used by debugger/REPL.
 extension Tensor: CustomReflectable {
+    @_semantics("autodiff.nonvarying")
     public var customMirror: Mirror {
         return Mirror(self, children: [], displayStyle: .struct)
     }

From 874ad803edceb71122045b57a5364bcce47b09a3 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 21 Apr 2019 14:35:29 -0400
Subject: [PATCH 02/55] Minor bug fix.

---
 Sources/DeepLearning/Operators/Math.swift | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/DeepLearning/Operators/Math.swift
index 3255aea10..9a2cecebf 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/DeepLearning/Operators/Math.swift
@@ -875,7 +875,7 @@ public extension Tensor where Scalar == Bool {
     @inlinable
     func all() -> Bool {
         let axes = Tensor<Int32>(rangeFrom: 0, to: Int32(rank), stride: 1)
-        return _TFGetScalarOrDie(Raw.all(self, reductionIndices: axes).handle)
+        return Raw.all(self, reductionIndices: axes).scalarized()
     }
 
     /// Returns `true` if any scalars are equal to `true`. Otherwise, returns `false`.
@@ -884,7 +884,7 @@ public extension Tensor where Scalar == Bool {
     @inlinable
     func any() -> Bool {
         let axes = Tensor<Int32>(rangeFrom: 0, to: Int32(rank), stride: 1)
-        return _TFGetScalarOrDie(Raw.any(self, reductionIndices: axes).handle)
+        return Raw.any(self, reductionIndices: axes).scalarized()
     }
 
     /// Performs a logical AND operation along the specified axes. The reduced dimensions are

From 21904cc146fbfebd0f8adbda74925d992ca2e076 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 21 Apr 2019 15:43:37 -0400
Subject: [PATCH 03/55] Fixed some compiler errors.

---
 Sources/DeepLearning/Initializers.swift     |  2 +-
 Sources/DeepLearning/PythonConversion.swift | 46 ++++++++++-----------
 Sources/DeepLearning/Tensors.swift          | 42 ++++++++++++-------
 3 files changed, 52 insertions(+), 38 deletions(-)

diff --git a/Sources/DeepLearning/Initializers.swift b/Sources/DeepLearning/Initializers.swift
index 3ab3f5654..a832a86b5 100644
--- a/Sources/DeepLearning/Initializers.swift
+++ b/Sources/DeepLearning/Initializers.swift
@@ -205,7 +205,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
         alongAxis axis: Int = 0
     ) -> (Tensor, (Tensor) -> Array<Tensor>.DifferentiableView) {
         let result = Tensor<Scalar>(concatenating: tensors, alongAxis: axis)
-        let posAxis = axis < 0 ? axis + tensors[0].rank: axis
+        let posAxis = axis < 0 ? axis + tensors[0].rank : axis
         let sizes = Tensor<Int32>(stacking: tensors.map { $0.shapeTensor[posAxis] })
         return (result, { [count = tensors.count] v in
             if count == 1 { return Array<Tensor>.DifferentiableView([v]) }
diff --git a/Sources/DeepLearning/PythonConversion.swift b/Sources/DeepLearning/PythonConversion.swift
index 5e52548c4..f5601ae6d 100644
--- a/Sources/DeepLearning/PythonConversion.swift
+++ b/Sources/DeepLearning/PythonConversion.swift
@@ -24,9 +24,9 @@ import Python
 // a Python import error until it is first used.
 private let np = Python.import("numpy")
 
-private func debugLogNumpyError(_ message: String) {
-    debugLog("NumPy conversion error: " + message)
-}
+// private func debugLogNumpyError(_ message: String) {
+//     debugLog("NumPy conversion error: " + message)
+// }
 
 extension ShapedArray: ConvertibleFromNumpyArray
     where Scalar: NumpyScalarCompatible {
@@ -39,25 +39,25 @@ extension ShapedArray: ConvertibleFromNumpyArray
     public init?(numpy numpyArray: PythonObject) {
         // Check if input is a `numpy.ndarray` instance.
         guard Python.isinstance(numpyArray, np.ndarray) == true else {
-            debugLogNumpyError("""
-                PythonObject input has type '\(Python.type(numpyArray))' and is not \
-                an instance of 'numpy.ndarray'.
-                """)
+            // debugLogNumpyError("""
+            //     PythonObject input has type '\(Python.type(numpyArray))' and is not \
+            //     an instance of 'numpy.ndarray'.
+            //     """)
             return nil
         }
         // Check if the dtype of the `ndarray` is compatible with the `Scalar`
         // type.
         guard Scalar.numpyScalarTypes.contains(numpyArray.dtype) else {
-            debugLogNumpyError("""
-                'numpy.ndarray' dtype '\(numpyArray.dtype)' is incompatible with \
-                Swift type '\(Scalar.self)'.
-                """)
+            // debugLogNumpyError("""
+            //     'numpy.ndarray' dtype '\(numpyArray.dtype)' is incompatible with \
+            //     Swift type '\(Scalar.self)'.
+            //     """)
             return nil
         }
 
         let pyShape = numpyArray.__array_interface__["shape"]
         guard let shape = [Int](pyShape) else {
-            debugLogNumpyError("cannot access shape of 'numpy.ndarray' instance.")
+            // debugLogNumpyError("cannot access shape of 'numpy.ndarray' instance.")
             return nil
         }
 
@@ -67,7 +67,7 @@ extension ShapedArray: ConvertibleFromNumpyArray
 
         guard let ptrVal =
             UInt(contiguousNumpyArray.__array_interface__["data"].tuple2.0) else {
-            debugLogNumpyError("cannot access data of 'numpy.ndarray' instance.")
+            // debugLogNumpyError("cannot access data of 'numpy.ndarray' instance.")
             return nil
         }
         // Note: `ptr` is not nil even if the `ndarray` is empty (i.e. has a shape
@@ -103,25 +103,25 @@ extension Tensor: ConvertibleFromNumpyArray
     public init?(numpy numpyArray: PythonObject) {
         // Check if input is a `numpy.ndarray` instance.
         guard Python.isinstance(numpyArray, np.ndarray) == true else {
-            debugLogNumpyError("""
-                PythonObject input has type '\(Python.type(numpyArray))' and is not \
-                an instance of 'numpy.ndarray'.
-                """)
+            // debugLogNumpyError("""
+            //     PythonObject input has type '\(Python.type(numpyArray))' and is not \
+            //     an instance of 'numpy.ndarray'.
+            //     """)
             return nil
         }
         // Check if the dtype of the `ndarray` is compatible with the `Scalar`
         // type.
         guard Scalar.numpyScalarTypes.contains(numpyArray.dtype) else {
-            debugLogNumpyError("""
-                'numpy.ndarray' dtype '\(numpyArray.dtype)' is incompatible with \
-                Swift type '\(Scalar.self)'.
-                """)
+            // debugLogNumpyError("""
+            //     'numpy.ndarray' dtype '\(numpyArray.dtype)' is incompatible with \
+            //     Swift type '\(Scalar.self)'.
+            //     """)
             return nil
         }
 
         let pyShape = numpyArray.__array_interface__["shape"]
         guard let dimensions = [Int](pyShape) else {
-            debugLogNumpyError("cannot access shape of 'numpy.ndarray' instance.")
+            // debugLogNumpyError("cannot access shape of 'numpy.ndarray' instance.")
             return nil
         }
         let shape = TensorShape(dimensions)
@@ -131,7 +131,7 @@ extension Tensor: ConvertibleFromNumpyArray
         let contiguousNumpyArray = np.ascontiguousarray(numpyArray)
 
         guard let ptrVal = UInt(contiguousNumpyArray.__array_interface__["data"].tuple2.0) else {
-            debugLogNumpyError("cannot access data of 'numpy.ndarray' instance.")
+            // debugLogNumpyError("cannot access data of 'numpy.ndarray' instance.")
             return nil
         }
         // Note: `ptr` is not nil even if the `ndarray` is empty (i.e. has a shape
diff --git a/Sources/DeepLearning/Tensors.swift b/Sources/DeepLearning/Tensors.swift
index ad6f758a6..7be5c5c9d 100644
--- a/Sources/DeepLearning/Tensors.swift
+++ b/Sources/DeepLearning/Tensors.swift
@@ -27,23 +27,29 @@ infix operator .==: ComparisonPrecedence
 public extension Tensor {
   /// The rank of the tensor, represented as a `Tensor<Int32>`.
   @inlinable
-  @_semantics("autodiff.nonvarying")
   var rankTensor: Tensor<Int32> {
-    return Raw.rank(self)
+    @_semantics("autodiff.nonvarying")
+    get {
+        return Raw.rank(self)
+    }
   }
 
   /// The dimensions of the tensor, represented as a `Tensor<Int32>`.
   @inlinable
-  @_semantics("autodiff.nonvarying")
   var shapeTensor: Tensor<Int32> {
-    return Raw.shape(self)
+    @_semantics("autodiff.nonvarying")
+    get {
+        return Raw.shape(self)
+    }
   }
 
   /// The number of scalars in the tensor, represented as a `Tensor<Int32>`.
   @inlinable
-  @_semantics("autodiff.nonvarying")
   var scalarCountTensor: Tensor<Int32> {
-    return Raw.size(self)
+    @_semantics("autodiff.nonvarying")
+    get {
+        return Raw.size(self)
+    }
   }
 }
 
@@ -56,9 +62,11 @@ extension Tensor: CustomStringConvertible {
     /// A textual representation of the tensor.
     ///
     /// - Note: use `fullDescription` for a non-pretty-printed description showing all scalars.
-    @_semantics("autodiff.nonvarying")
     public var description: String {
-        return array.description
+        @_semantics("autodiff.nonvarying")
+        get {
+            return array.description
+        }
     }
 }
 
@@ -87,25 +95,31 @@ public extension Tensor {
 
     /// A full, non-pretty-printed textual representation of the tensor, showing
     /// all scalars.
-    @_semantics("autodiff.nonvarying")
     var fullDescription: String {
-        return array.fullDescription
+        @_semantics("autodiff.nonvarying")
+        get {
+            return array.fullDescription
+        }
     }
 }
 
 // Xcode Playground display conversion.
 extension Tensor: CustomPlaygroundDisplayConvertible {
-    @_semantics("autodiff.nonvarying")
     public var playgroundDescription: Any {
-        return description
+        @_semantics("autodiff.nonvarying")
+        get {
+            return description
+        }
     }
 }
 
 // Mirror representation, used by debugger/REPL.
 extension Tensor: CustomReflectable {
-    @_semantics("autodiff.nonvarying")
     public var customMirror: Mirror {
-        return Mirror(self, children: [], displayStyle: .struct)
+        @_semantics("autodiff.nonvarying")
+        get {
+            return Mirror(self, children: [], displayStyle: .struct)
+        }
     }
 }
 

From 8cb09bc55dab0ed3be2dd95adc5716d1be648de2 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 21 Apr 2019 16:12:03 -0400
Subject: [PATCH 04/55] Added a couple of missing function overloads.

---
 Sources/DeepLearning/Operators/Math.swift | 42 ++++++++++++++++++++---
 1 file changed, 38 insertions(+), 4 deletions(-)

diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/DeepLearning/Operators/Math.swift
index 9a2cecebf..f134ddf03 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/DeepLearning/Operators/Math.swift
@@ -945,13 +945,21 @@ public extension Tensor where Scalar: Numeric & Comparable {
         return Raw.max(self, reductionIndices: axes)
     }
 
+    /// Returns the maximum values along the specified axes. The reduced dimensions are removed.
+    /// - Parameter axes: The dimensions to reduce.
+    /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
+    @inlinable
+    func max(squeezingAxes axes: Tensor<Int32>) -> Tensor {
+        return Raw.max(self, reductionIndices: axes, keepDims: false)
+    }
+
     /// Returns the maximum values along the specified axes. The reduced dimensions are removed.
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
     @inlinable
     func max(squeezingAxes axes: [Int]) -> Tensor {
         let axes = axes.map(Int32.init)
-        return Raw.max(self, reductionIndices: Tensor<Int32>(axes), keepDims: false)
+        return max(squeezingAxes: Tensor<Int32>(axes))
     }
 
     /// Returns the maximum values along the specified axes. The reduced dimensions are removed.
@@ -962,13 +970,21 @@ public extension Tensor where Scalar: Numeric & Comparable {
         return max(squeezingAxes: axes)
     }
 
+    /// Returns the minimum values along the specified axes. The reduced dimensions are removed.
+    /// - Parameter axes: The dimensions to reduce.
+    /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
+    @inlinable
+    func min(squeezingAxes axes: Tensor<Int32>) -> Tensor {
+        return Raw.min(self, reductionIndices: axes, keepDims: false)
+    }
+
     /// Returns the minimum values along the specified axes. The reduced dimensions are removed.
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
     @inlinable
     func min(squeezingAxes axes: [Int]) -> Tensor {
         let axes = axes.map(Int32.init)
-        return Raw.min(self, reductionIndices: Tensor<Int32>(axes), keepDims: false)
+        return min(squeezingAxes: Tensor<Int32>(axes))
     }
 
     /// Returns the minimum values along the specified axes. The reduced dimensions are removed.
@@ -997,6 +1013,15 @@ public extension Tensor where Scalar: Numeric & Comparable {
         return Raw.argMin(self, dimension: Tensor<Int32>(Int32(axis)))
     }
 
+    /// Returns the minimum along the specified axes. The reduced dimensions are retained with
+    /// value 1.
+    /// - Parameter axes: The dimensions to reduce.
+    /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
+    @inlinable
+    func min(alongAxes axes: Tensor<Int32>) -> Tensor {
+        return Raw.min(self, reductionIndices: axes, keepDims: true)
+    }
+
     /// Returns the minimum along the specified axes. The reduced dimensions are retained with
     /// value 1.
     /// - Parameter axes: The dimensions to reduce.
@@ -1004,7 +1029,7 @@ public extension Tensor where Scalar: Numeric & Comparable {
     @inlinable
     func min(alongAxes axes: [Int]) -> Tensor {
         let axes = axes.map(Int32.init)
-        return Raw.min(self, reductionIndices: Tensor<Int32>(axes), keepDims: true)
+        return min(alongAxes: Tensor<Int32>(axes))
     }
 
     /// Returns the minimum along the specified axes. The reduced dimensions are retained with
@@ -1016,6 +1041,15 @@ public extension Tensor where Scalar: Numeric & Comparable {
         return min(alongAxes: axes)
     }
 
+    /// Returns the minimum along the specified axes. The reduced dimensions are retained with
+    /// value 1.
+    /// - Parameter axes: The dimensions to reduce.
+    /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
+    @inlinable
+    func max(alongAxes axes: Tensor<Int32>) -> Tensor {
+        return Raw.max(self, reductionIndices: axes, keepDims: true)
+    }
+
     /// Returns the minimum along the specified axes. The reduced dimensions are retained with
     /// value 1.
     /// - Parameter axes: The dimensions to reduce.
@@ -1023,7 +1057,7 @@ public extension Tensor where Scalar: Numeric & Comparable {
     @inlinable
     func max(alongAxes axes: [Int]) -> Tensor {
         let axes = axes.map(Int32.init)
-        return Raw.max(self, reductionIndices: Tensor<Int32>(axes), keepDims: true)
+        return max(alongAxes: axes)
     }
 
     /// Returns the minimum along the specified axes. The reduced dimensions are retained with

From 84fd4419f53dd313efc9631bc105828adeb8228b Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 21 Apr 2019 18:23:31 -0400
Subject: [PATCH 05/55] Bug fix.

---
 Sources/DeepLearning/Operators/Math.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/DeepLearning/Operators/Math.swift
index f134ddf03..848dc359b 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/DeepLearning/Operators/Math.swift
@@ -1057,7 +1057,7 @@ public extension Tensor where Scalar: Numeric & Comparable {
     @inlinable
     func max(alongAxes axes: [Int]) -> Tensor {
         let axes = axes.map(Int32.init)
-        return max(alongAxes: axes)
+        return max(alongAxes: Tensor<Int32>(axes))
     }
 
     /// Returns the minimum along the specified axes. The reduced dimensions are retained with

From c543e76a1e8f354dce44baa9ada49240d59e9ea2 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 21 Apr 2019 18:57:51 -0400
Subject: [PATCH 06/55] Added VJPs for min and max.

---
 Sources/DeepLearning/Operators/Math.swift | 44 +++++++++++++++++++++--
 1 file changed, 42 insertions(+), 2 deletions(-)

diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/DeepLearning/Operators/Math.swift
index 848dc359b..7400ddb33 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/DeepLearning/Operators/Math.swift
@@ -934,7 +934,7 @@ public extension Tensor where Scalar: Numeric & Comparable {
     @inlinable
     func min() -> Tensor {
         let axes = Tensor<Int32>(rangeFrom: 0, to: Int32(rank), stride: 1)
-        return Raw.min(self, reductionIndices: axes)
+        return min(squeezingAxes: axes)
     }
 
     // NOTE: This overload is necessary, otherwise `max()` would refer to the variadic method
@@ -942,13 +942,14 @@ public extension Tensor where Scalar: Numeric & Comparable {
     @inlinable
     func max() -> Tensor {
         let axes = Tensor<Int32>(rangeFrom: 0, to: Int32(rank), stride: 1)
-        return Raw.max(self, reductionIndices: axes)
+        return max(squeezingAxes: axes)
     }
 
     /// Returns the maximum values along the specified axes. The reduced dimensions are removed.
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
     @inlinable
+    @differentiable(wrt: self, vjp: _vjpMinOrMax(squeezingAxes:) where Scalar: TensorFlowFloatingPoint)
     func max(squeezingAxes axes: Tensor<Int32>) -> Tensor {
         return Raw.max(self, reductionIndices: axes, keepDims: false)
     }
@@ -974,6 +975,7 @@ public extension Tensor where Scalar: Numeric & Comparable {
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
     @inlinable
+    @differentiable(wrt: self, vjp: _vjpMinOrMax(squeezing:) where Scalar: TensorFlowFloatingPoint)
     func min(squeezingAxes axes: Tensor<Int32>) -> Tensor {
         return Raw.min(self, reductionIndices: axes, keepDims: false)
     }
@@ -1018,6 +1020,7 @@ public extension Tensor where Scalar: Numeric & Comparable {
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
     @inlinable
+    @differentiable(wrt: self, vjp: _vjpMinOrMax(alongAxes:) where Scalar: TensorFlowFloatingPoint)
     func min(alongAxes axes: Tensor<Int32>) -> Tensor {
         return Raw.min(self, reductionIndices: axes, keepDims: true)
     }
@@ -1046,6 +1049,7 @@ public extension Tensor where Scalar: Numeric & Comparable {
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
     @inlinable
+    @differentiable(wrt: self, vjp: _vjpMinOrMax(alongAxes:) where Scalar: TensorFlowFloatingPoint)
     func max(alongAxes axes: Tensor<Int32>) -> Tensor {
         return Raw.max(self, reductionIndices: axes, keepDims: true)
     }
@@ -1082,6 +1086,42 @@ public extension Tensor where Scalar: Numeric & Comparable {
     }
 }
 
+internal extension Tensor where Scalar: TensorFlowFloatingPoint {
+  @inlinable
+  func _vjpMinOrMax(squeezingAxes axes: Tensor<Int32>) -> (Tensor, (Tensor) -> Tensor) {
+    let result = max(squeezingAxes: axes)
+    return (result, { v in
+      var y = result
+      var gradient = v
+      for i in axes.array.scalars {
+        y = y.expandingShape(at: Int(i))
+        gradient = gradient.expandingShape(at: Int(i))
+      }
+
+      // Compute the number of selected (maximum or minimum) elements in each reduction dimension.
+      // If there are multiple minimum or maximum elements then the gradient will be divided between
+      // them.
+      let indicators = Tensor(y .== self)
+      let selectedCount = indicators.sum(alongAxes: axes)
+
+      return gradient.broadcast(toShape: self.shapeTensor) * indicators / selectedCount
+    })
+  }
+
+  @inlinable
+  func _vjpMinOrMax(alongAxes axes: Tensor<Int32>) -> (Tensor, (Tensor) -> Tensor) {
+    let result = max(squeezingAxes: axes)
+    return (result, { v in
+      // Compute the number of selected (maximum or minimum) elements in each reduction dimension.
+      // If there are multiple minimum or maximum elements then the gradient will be divided between
+      // them.
+      let indicators = Tensor(result .== self)
+      let selectedCount = indicators.sum(alongAxes: axes)
+      return v.broadcast(toShape: self.shapeTensor) * indicators / selectedCount
+    })
+  }
+}
+
 // MARK: - Numeric Reductions
 
 public extension Tensor where Scalar: Numeric {

From 262a5692f0c840d8b0ab109be3c080e92e469e92 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 21 Apr 2019 18:58:38 -0400
Subject: [PATCH 07/55] Minor edits.

---
 Sources/DeepLearning/Operators/Math.swift | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/DeepLearning/Operators/Math.swift
index 7400ddb33..ba5d664b1 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/DeepLearning/Operators/Math.swift
@@ -949,7 +949,9 @@ public extension Tensor where Scalar: Numeric & Comparable {
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
     @inlinable
-    @differentiable(wrt: self, vjp: _vjpMinOrMax(squeezingAxes:) where Scalar: TensorFlowFloatingPoint)
+    @differentiable(
+        wrt: self,
+        vjp: _vjpMinOrMax(squeezingAxes:) where Scalar: TensorFlowFloatingPoint)
     func max(squeezingAxes axes: Tensor<Int32>) -> Tensor {
         return Raw.max(self, reductionIndices: axes, keepDims: false)
     }
@@ -975,7 +977,9 @@ public extension Tensor where Scalar: Numeric & Comparable {
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
     @inlinable
-    @differentiable(wrt: self, vjp: _vjpMinOrMax(squeezing:) where Scalar: TensorFlowFloatingPoint)
+    @differentiable(
+        wrt: self,
+        vjp: _vjpMinOrMax(squeezingAxes:) where Scalar: TensorFlowFloatingPoint)
     func min(squeezingAxes axes: Tensor<Int32>) -> Tensor {
         return Raw.min(self, reductionIndices: axes, keepDims: false)
     }

From 9513dc6592f9dccdb3211966f1a993376268bdc6 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 21 Apr 2019 20:40:42 -0400
Subject: [PATCH 08/55] Bug fix.

---
 Sources/DeepLearning/Operators/Math.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/DeepLearning/Operators/Math.swift
index ba5d664b1..fa22b7190 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/DeepLearning/Operators/Math.swift
@@ -1114,7 +1114,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
 
   @inlinable
   func _vjpMinOrMax(alongAxes axes: Tensor<Int32>) -> (Tensor, (Tensor) -> Tensor) {
-    let result = max(squeezingAxes: axes)
+    let result = max(alongAxes: axes)
     return (result, { v in
       // Compute the number of selected (maximum or minimum) elements in each reduction dimension.
       // If there are multiple minimum or maximum elements then the gradient will be divided between

From 7c8d0eabc424f825ec9b70f9f1a9c7836d3c9058 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Mon, 22 Apr 2019 00:20:27 -0400
Subject: [PATCH 09/55] Bug fix.

---
 Sources/DeepLearning/Operators/Math.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/DeepLearning/Operators/Math.swift
index fa22b7190..3319b7e3d 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/DeepLearning/Operators/Math.swift
@@ -1170,7 +1170,7 @@ public extension Tensor where Scalar: Numeric {
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
     @inlinable
-    @differentiable(wrt: self, vjp: _vjpSum(squeezingAxes:) where Scalar: TensorFlowFloatingPoint)
+    @differentiable(wrt: self, vjp: _vjpSum(alongAxes:) where Scalar: TensorFlowFloatingPoint)
     func sum(alongAxes axes: Tensor<Int32>) -> Tensor {
         return Raw.sum(self, reductionIndices: axes, keepDims: true)
     }

From a231f6be19f677195d8231eaae0453b8dad56b0c Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Tue, 23 Apr 2019 17:01:52 -0400
Subject: [PATCH 10/55] Brought the dataset ops from the stdlib.

---
 Sources/DeepLearning/Operators/Dataset.swift | 224 +++++++++++++++++++
 1 file changed, 224 insertions(+)
 create mode 100644 Sources/DeepLearning/Operators/Dataset.swift

diff --git a/Sources/DeepLearning/Operators/Dataset.swift b/Sources/DeepLearning/Operators/Dataset.swift
new file mode 100644
index 000000000..40ca4c7cc
--- /dev/null
+++ b/Sources/DeepLearning/Operators/Dataset.swift
@@ -0,0 +1,224 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+#if !COMPILING_TENSORFLOW_MODULE
+import TensorFlow
+#endif
+
+/// The default graph seed.
+///
+/// - Note: See TensorFlow's `python.framework.random_seed.DEFAULT_GRAPH_SEED`.
+@usableFromInline let _defaultGraphSeed: Int64 = 87654321
+
+/// Returns the local seeds an operation should use given an op-specific seed.
+///
+/// Given operation-specific seed, `seed`, this helper function returns two
+/// seeds derived from graph-level and op-level seeds. Many random operations
+/// internally use the two seeds to allow user to change the seed globally for a
+/// graph, or for only specific operations.
+///
+/// - Note: See TensorFlow's `python.framework.random_seed.get_seed`.
+///
+// TODO: There's no support for TF's "global seed" yet, so we always use the
+// default graph seed as the first seed. Need to investigate the best way to
+// model TF's "global seed".
+@usableFromInline @inline(__always)
+func _tensorSeeds(_ seed: Tensor<Int64>) -> (Tensor<Int64>, Tensor<Int64>) {
+  return (Tensor(_defaultGraphSeed), seed)
+}
+
+//===----------------------------------------------------------------------===//
+// Single value dataset
+//===----------------------------------------------------------------------===//
+
+/// Represents a potentially large set of elements.
+///
+/// A `Dataset` can be used to represent an input pipeline as a collection of
+/// element tensors.
+@_fixed_layout
+public struct Dataset<Element: TensorGroup> {
+  public let _handle: VariantHandle
+
+  @inlinable @inline(__always)
+  public init(_handle: VariantHandle) {
+    self._handle = _handle
+  }
+}
+
+public extension Dataset {
+  @inlinable @inline(__always)
+  init(randomSeed: Int64) {
+    let (seed1, seed2) = _tensorSeeds(Tensor(randomSeed))
+    self.init(_handle: Raw.experimentalRandomDataset(
+      seed: seed1,
+      seed2: seed2,
+      outputTypes: Element._typeList,
+      outputShapes: Element._unknownShapeList))
+  }
+}
+
+public extension Dataset {
+  /// Creates a dataset from a batch of elements as a tensor.
+  @inlinable @inline(__always)
+  init(elements: Element) {
+    // A dataset creation op only runs on TF CPU.
+    self.init(_handle: Raw.tensorSliceDataset(
+      components: elements,
+      outputShapes: Element._unknownShapeList))
+  }
+}
+
+extension Dataset: Sequence {
+  public typealias Iterator = DatasetIterator<Element>
+
+  /// Returns an iterator over the elements of this dataset.
+  @inlinable @inline(__always)
+  public func makeIterator() -> DatasetIterator<Element> {
+    let resource = Raw.anonymousIterator(
+      outputTypes: Element._typeList,
+      outputShapes: Element._unknownShapeList)
+    Raw.makeIterator(dataset: _handle, iterator: resource)
+    return DatasetIterator(_handle: resource)
+  }
+}
+
+public extension Dataset {
+  // Note that this Dataset API implementation uses an experimental tracing
+  // feature, which is not robust and does not have great diagnostics yet.
+  @inlinable @inline(__always)
+  func map<ResultElement: TensorGroup>(
+    _ transform: (Element) -> ResultElement
+  ) -> Dataset<ResultElement> {
+    return Dataset<ResultElement>(_handle: Raw.mapDataset(
+      inputDataset: _handle,
+      otherArguments: Tensor<Int32>(0),
+      f: transform,
+      outputTypes: ResultElement._typeList,
+      outputShapes: ResultElement._unknownShapeList,
+      useInterOpParallelism: true,
+      preserveCardinality: false))
+  }
+
+  @inlinable @inline(__always)
+  func filter(
+    _ isIncluded: (Element) -> Tensor<Bool>
+  ) -> Dataset {
+    return Dataset(_handle: Raw.filterDataset(
+      inputDataset: _handle,
+      otherArguments: Tensor<Int32>(0),
+      predicate: isIncluded,
+      outputTypes: Element._typeList,
+      outputShapes: Element._unknownShapeList))
+  }
+}
+
+public extension Dataset {
+  @inlinable @inline(__always)
+  func prefetched(count: Int) -> Dataset {
+    return Dataset(_handle: Raw.prefetchDataset(
+      inputDataset: _handle,
+      bufferSize: Tensor(Int64(count)),
+      outputTypes: Element._typeList,
+      outputShapes: Element._unknownShapeList))
+  }
+
+  @inlinable @inline(__always)
+  func shuffled(
+    sampleCount: Int,
+    randomSeed: Int64,
+    reshuffleForEachIterator: Bool = true
+  ) -> Dataset {
+    let (seed1, seed2) = _tensorSeeds(Tensor(randomSeed))
+    return Dataset(_handle: Raw.shuffleDataset(
+      inputDataset: _handle,
+      bufferSize: Tensor(Int64(sampleCount)),
+      seed: seed1,
+      seed2: seed2,
+      reshuffleEachIteration: reshuffleForEachIterator,
+      outputTypes: Element._typeList,
+      outputShapes: Element._unknownShapeList))
+  }
+
+  @inlinable @inline(__always)
+  func batched(_ batchSize: Int) -> Dataset {
+    return Dataset(_handle: Raw.batchDataset(
+      inputDataset: _handle,
+      batchSize: Tensor(Int64(batchSize)),
+      outputTypes: Element._typeList,
+      outputShapes: Element._unknownShapeList))
+  }
+
+  @inlinable @inline(__always)
+  func repeated(count: Int? = nil) -> Dataset {
+    return Dataset(_handle: Raw.repeatDataset(
+      inputDataset: _handle,
+      count: Tensor(Int64(count ?? -1)),
+      outputTypes: Element._typeList,
+      outputShapes: Element._unknownShapeList))
+  }
+}
+
+/// The type that allows iteration over a dataset's elements.
+@_fixed_layout
+public struct DatasetIterator<Element: TensorGroup> {
+  @usableFromInline let _handle: ResourceHandle
+
+  @usableFromInline @inline(__always)
+  internal init(_handle: ResourceHandle) {
+    self._handle = _handle
+  }
+}
+
+extension DatasetIterator: IteratorProtocol {
+  /// Advances to the next element and returns it, or `nil` if no next element
+  /// exists.
+  @inlinable @inline(__always)
+  public mutating func next() -> Element? {
+    let optional = Raw.iteratorGetNextAsOptional(
+      iterator: _handle,
+      outputTypes: Element._typeList,
+      outputShapes: Element._unknownShapeList)
+    guard Raw.optionalHasValue(optional: optional).scalarized() else {
+      return nil
+    }
+    return Raw.optionalGetValue(
+      optional: optional,
+      outputShapes: Element._unknownShapeList)
+  }
+}
+
+/// A 2-tuple-like struct that conforms to TensorGroup that represents a tuple 
+/// of 2 types conforming to TensorGroup.
+@_fixed_layout
+public struct Zip2TensorGroup<T: TensorGroup, U: TensorGroup>: TensorGroup {
+  public var first: T
+  public var second: U
+
+  public init(_ first: T, _ second: U) {
+    self.first = first
+    self.second = second
+  }
+}
+
+// TODO(SR-9156): This does not work in graph mode.
+@inlinable @inline(__always)
+public func zip<T: TensorGroup, U: TensorGroup>(
+  _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
+) -> Dataset<Zip2TensorGroup<T, U>> {
+  let handle = Raw.zipDataset(
+    inputDatasets: [dataset1._handle, dataset2._handle],
+    outputTypes: Zip2TensorGroup<T, U>._typeList,
+    outputShapes: Zip2TensorGroup<T, U>._unknownShapeList)
+  return Dataset(_handle: handle)
+}

From a7b98a8fd9bd5dbf07960e54e7c90fad633fe3b6 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Wed, 24 Apr 2019 21:30:51 -0400
Subject: [PATCH 11/55] TensorFlow/TensorFlowCore refactoring.

---
 Sources/DeepLearning/Context.swift            |   4 +-
 .../DeepLearning/DifferentialOperators.swift  |   4 +-
 Sources/DeepLearning/Helpers.swift            |   4 +-
 Sources/DeepLearning/Initializers.swift       |  43 +-
 Sources/DeepLearning/Layer.swift              | 534 +++++++++---------
 Sources/DeepLearning/Loss.swift               |   4 +-
 Sources/DeepLearning/Operators/Basic.swift    |  22 +-
 .../DeepLearning/Operators/Comparison.swift   |  79 ++-
 Sources/DeepLearning/Operators/Dataset.swift  |   6 +-
 Sources/DeepLearning/Operators/Math.swift     | 125 +---
 Sources/DeepLearning/Operators/NN.swift       |   4 +-
 Sources/DeepLearning/Optimizer.swift          |   4 +-
 Sources/DeepLearning/PythonConversion.swift   |   4 +-
 .../{Tensors.swift => Tensor.swift}           |  41 +-
 14 files changed, 377 insertions(+), 501 deletions(-)
 rename Sources/DeepLearning/{Tensors.swift => Tensor.swift} (78%)

diff --git a/Sources/DeepLearning/Context.swift b/Sources/DeepLearning/Context.swift
index 266ab2902..c607e902e 100644
--- a/Sources/DeepLearning/Context.swift
+++ b/Sources/DeepLearning/Context.swift
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
 #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
 import Darwin
diff --git a/Sources/DeepLearning/DifferentialOperators.swift b/Sources/DeepLearning/DifferentialOperators.swift
index bfb53db77..e499e737e 100644
--- a/Sources/DeepLearning/DifferentialOperators.swift
+++ b/Sources/DeepLearning/DifferentialOperators.swift
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
 //===------------------------------------------------------------------------------------------===//
 // Method-style Differential Operators
diff --git a/Sources/DeepLearning/Helpers.swift b/Sources/DeepLearning/Helpers.swift
index 4d9c0217b..1d56b0f76 100644
--- a/Sources/DeepLearning/Helpers.swift
+++ b/Sources/DeepLearning/Helpers.swift
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-@_exported import TensorFlow
-#endif
+@_exported import TensorFlowCore
 
 /// Returns a tensor with the same shape and scalars as the specified tensor.
 @inlinable
diff --git a/Sources/DeepLearning/Initializers.swift b/Sources/DeepLearning/Initializers.swift
index a832a86b5..6a35ef3f6 100644
--- a/Sources/DeepLearning/Initializers.swift
+++ b/Sources/DeepLearning/Initializers.swift
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
 public extension Tensor {
     /// Creates a tensor with the specified shape and a single, repeated scalar
@@ -23,7 +21,7 @@ public extension Tensor {
     /// - Parameters:
     ///   - shape: The dimensions of the tensor.
     ///   - repeatedValue: The scalar value to repeat.
-    @inlinable
+    @inlinable @inline(__always)
     @available(*, deprecated, renamed: "init(repeating:shape:)")
     init(shape: TensorShape, repeating repeatedValue: Scalar) {
         self.init(repeating: repeatedValue, shape: shape)
@@ -34,7 +32,7 @@ public extension Tensor {
     /// - Parameters:
     ///   - repeatedValue: The scalar value to repeat.
     ///   - shape: The dimensions of the tensor.
-    @inlinable
+    @inlinable @inline(__always)
     @differentiable(
         vjp: _vjpInit(repeating:shape:) where Scalar: TensorFlowFloatingPoint)
     init(repeating repeatedValue: Scalar, shape: TensorShape) {
@@ -45,7 +43,7 @@ public extension Tensor {
 
     /// Creates a tensor by broadcasting the given scalar to a given rank with
     /// all dimensions being 1.
-    @inlinable
+    @inlinable @inline(__always)
     // @differentiable(where Scalar: TensorFlowFloatingPoint)
     init(broadcasting scalar: Scalar, rank: Int) {
         self = Tensor(scalar).reshaped(to: TensorShape(repeating: 1, count: rank))
@@ -54,7 +52,7 @@ public extension Tensor {
     /// Creates a tensor of shape `[4]` from a 4-tuple.
     /// - Note: This is intended for internal use, for example, to initialize a
     ///   tensor attribute from `convolved2D`'s `strides` argument.
-    @inlinable
+    @inlinable @inline(__always)
     internal init(_ scalars: (Scalar, Scalar, Scalar, Scalar)) {
         self.init([scalars.0, scalars.1, scalars.2, scalars.3])
     }
@@ -78,13 +76,13 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
 
 public extension Tensor where Scalar: Numeric {
     /// Perform an element-wise type conversion from a `Bool` tensor.
-    @inlinable
+    @inlinable @inline(__always)
     init(_ other: Tensor<Bool>) {
         self = Raw.cast(other)
     }
 
     /// Perform an element-wise conversion from another `Tensor`.
-    @inlinable
+    @inlinable @inline(__always)
     @differentiable(
         vjp: _vjpCast where Scalar: TensorFlowFloatingPoint, OtherScalar: TensorFlowFloatingPoint)
     init<OtherScalar: Numeric>(_ other: Tensor<OtherScalar>) {
@@ -107,10 +105,10 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
 
 public extension Tensor {
     /// Creates a tensor from an array of tensors (which may themselves be scalars).
-    @inlinable
-    @differentiable(where Scalar: TensorFlowFloatingPoint)
+    @inlinable @inline(__always)
+    @differentiable(vjp: _vjpInitElements where Scalar: TensorFlowFloatingPoint)
     init(_ elements: [Tensor]) {
-        self = Tensor(stacking: elements)
+        self = Raw.pack(elements)
     }
 
     /// Stacks `tensors`, along the `axis` dimension, into a new tensor with rank one higher than
@@ -141,7 +139,7 @@ public extension Tensor {
     ///   provided tensors.
     /// 
     /// - Returns: The stacked tensor.
-    @inlinable
+    @inlinable @inline(__always)
     @differentiable(vjp: _vjpStacking where Scalar: TensorFlowFloatingPoint)
     init(stacking tensors: [Tensor], alongAxis axis: Int = 0) {
         self = Raw.pack(tensors, axis: Int64(axis))
@@ -179,7 +177,7 @@ public extension Tensor {
     ///   provided tensors.
     /// 
     /// - Returns: The concatenated tensor.
-    @inlinable
+    @inlinable @inline(__always)
     @differentiable(vjp: _vjpConcatenating where Scalar: TensorFlowFloatingPoint)
     init(concatenating tensors: [Tensor], alongAxis axis: Int = 0) {
         precondition(tensors.count > 0)
@@ -188,6 +186,13 @@ public extension Tensor {
 }
 
 internal extension Tensor where Scalar: TensorFlowFloatingPoint {
+    @inlinable
+    static func _vjpInitElements(
+        _ elements: [Tensor]
+    ) -> (Tensor, (Tensor) -> Array<Tensor>.DifferentiableView) {
+        return _vjpStacking(stacking: elements)
+    }
+
     @inlinable
     static func _vjpStacking(
         stacking tensors: [Tensor],
@@ -223,7 +228,7 @@ public extension Tensor where Scalar: Numeric {
     /// Creates a tensor with all scalars set to zero.
     ///
     /// - Parameter shape: Shape of the tensor.
-    @inlinable
+    @inlinable @inline(__always)
     init(zeros shape: TensorShape) {
         self.init(repeating: 0, shape: shape)
     }
@@ -231,7 +236,7 @@ public extension Tensor where Scalar: Numeric {
     /// Creates a tensor with all scalars set to one.
     ///
     /// - Parameter shape: Shape of the tensor.
-    @inlinable
+    @inlinable @inline(__always)
     init(ones shape: TensorShape) {
         self.init(repeating: 1, shape: shape)
     }
@@ -246,8 +251,7 @@ public extension Tensor where Scalar: Numeric {
     ///     the resulting sequence.
     ///   - stride: The amount to step by with each iteration. `stride` must be
     ///     positive.
-    ///
-    @inlinable
+    @inlinable @inline(__always)
     init(rangeFrom start: Scalar, to end: Scalar, stride: Scalar) {
         self = Raw.range(start: Tensor(start), limit: Tensor(end), delta: Tensor(stride))
     }
@@ -279,8 +283,7 @@ public extension Tensor where Scalar: Numeric {
     ///   - offValue: A scalar defining the value at a location that is not
     ///     referred to by any index in `indices`.
     ///   - axis: The axis to fill. The default is `-1`, a new inner-most axis.
-    ///
-    @inlinable
+    @inlinable @inline(__always)
     init(
         oneHotAtIndices indices: Tensor<Int32>,
         depth: Int,
diff --git a/Sources/DeepLearning/Layer.swift b/Sources/DeepLearning/Layer.swift
index 774521a18..81eb59444 100644
--- a/Sources/DeepLearning/Layer.swift
+++ b/Sources/DeepLearning/Layer.swift
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
 /// A neural network layer.
 ///
@@ -1226,269 +1224,269 @@ public struct Reshape<Scalar: TensorFlowFloatingPoint>: Layer {
     }
 }
 
-/// An input to a recurrent neural network.
-public struct RNNCellInput<Input: Differentiable, State: Differentiable>: Differentiable {
-    /// The input at the current time step.
-    public var input: Input
-    /// The previous state.
-    public var state: State
-
-    @differentiable
-    public init(input: Input, state: State) {
-        self.input = input
-        self.state = state
-    }
-}
-
-/// An output to a recurrent neural network.
-public struct RNNCellOutput<Output: Differentiable, State: Differentiable>: Differentiable {
-    /// The output at the current time step.
-    public var output: Output
-    /// The current state.
-    public var state: State
-
-    @differentiable
-    public init(output: Output, state: State) {
-        self.output = output
-        self.state = state
-    }
-}
-
-/// A recurrent neural network cell.
-public protocol RNNCell: Layer where Input == RNNCellInput<TimeStepInput, State>,
-                                     Output == RNNCellOutput<TimeStepOutput, State> {
-    /// The input at a time step.
-    associatedtype TimeStepInput: Differentiable
-    /// The output at a time step.
-    associatedtype TimeStepOutput: Differentiable
-    /// The state that may be preserved across time steps.
-    associatedtype State: Differentiable
-    /// The zero state.
-    var zeroState: State { get }
-}
-
-public extension RNNCell {
-    /// Returns the new state obtained from applying the RNN cell to the input at the current time
-    /// step and the previous state.
-    ///
-    /// - Parameters:
-    ///   - timeStepInput: The input at the current time step.
-    ///   - previousState: The previous state of the RNN cell.
-    /// - Returns: The output.
-    @differentiable
-    func call(input: TimeStepInput, state: State) -> RNNCellOutput<TimeStepOutput, State> {
-        return self(RNNCellInput(input: input, state: state))
-    }
-}
-
-/// A Simple RNN Cell.
-public struct SimpleRNNCell<Scalar: TensorFlowFloatingPoint>: RNNCell, VectorNumeric {
-    public var weight: Tensor<Scalar>
-    public var bias: Tensor<Scalar>
-
-    @noDerivative public var stateShape: TensorShape {
-        return TensorShape([1, weight.shape[1]])
-    }
-
-    public var zeroState: Tensor<Scalar> {
-        return Tensor(zeros: stateShape)
-    }
-
-    public typealias State = Tensor<Scalar>
-    public typealias TimeStepInput = Tensor<Scalar>
-    public typealias TimeStepOutput = State
-    public typealias Input = RNNCellInput<TimeStepInput, State>
-    public typealias Output = RNNCellOutput<TimeStepOutput, State>
-
-    /// Creates a `SimpleRNNCell` with the specified input size and hidden state size.
-    ///
-    /// - Parameters:
-    ///   - inputSize: The number of features in 2-D input tensors.
-    ///   - hiddenSize: The number of features in 2-D hidden states.
-    ///   - seed: The random seed for initialization. The default value is random.
-    public init(inputSize: Int, hiddenSize: Int,
-                seed: (Int64, Int64) = (Int64.random(in: Int64.min..<Int64.max),
-                                        Int64.random(in: Int64.min..<Int64.max))) {
-        let concatenatedInputSize = inputSize + hiddenSize
-        self.weight = Tensor(glorotUniform: [concatenatedInputSize, hiddenSize],
-                             seed: seed)
-        self.bias = Tensor(zeros: [hiddenSize])
-    }
-
-    /// Returns the output obtained from applying the layer to the given input.
-    ///
-    /// - Parameters:
-    ///   - input: The input to the layer.
-    ///   - context: The contextual information for the layer application, e.g. the current learning
-    ///     phase.
-    /// - Returns: The hidden state.
-    @differentiable
-    public func call(_ input: Input) -> Output {
-        let concatenatedInput = input.input.concatenated(with: input.state, alongAxis: 1)
-        let newState = tanh(matmul(concatenatedInput, weight) + bias)
-        return Output(output: newState, state: newState)
-    }
-}
-
-/// An LSTM Cell.
-public struct LSTMCell<Scalar: TensorFlowFloatingPoint>: RNNCell, VectorNumeric {
-    public var inputWeight, updateWeight, forgetWeight, outputWeight: Tensor<Scalar>
-    public var inputBias, updateBias, forgetBias, outputBias: Tensor<Scalar>
-
-    @noDerivative public var stateShape: TensorShape {
-        return TensorShape([1, inputWeight.shape[1]])
-    }
-
-    public var zeroState: State {
-        return State(cell: Tensor(zeros: stateShape), hidden: Tensor(zeros: stateShape))
-    }
-
-    public typealias TimeStepInput = Tensor<Scalar>
-    public typealias TimeStepOutput = State
-    public typealias Input = RNNCellInput<TimeStepInput, State>
-    public typealias Output = RNNCellOutput<TimeStepOutput, State>
-
-    /// Creates a `LSTMCell` with the specified input size and hidden state size.
-    ///
-    /// - Parameters:
-    ///   - inputSize: The number of features in 2-D input tensors.
-    ///   - hiddenSize: The number of features in 2-D hidden states.
-    public init(inputSize: Int, hiddenSize: Int,
-                seed: (Int64, Int64) = (Int64.random(in: Int64.min..<Int64.max),
-                                        Int64.random(in: Int64.min..<Int64.max))) {
-        let concatenatedInputSize = inputSize + hiddenSize
-        let gateWeightShape = TensorShape([concatenatedInputSize, hiddenSize])
-        let gateBiasShape = TensorShape([hiddenSize])
-        self.inputWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
-        self.inputBias = Tensor(zeros: gateBiasShape)
-        self.updateWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
-        self.updateBias = Tensor(zeros: gateBiasShape)
-        self.forgetWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
-        self.forgetBias = Tensor(ones: gateBiasShape)
-        self.outputWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
-        self.outputBias = Tensor(zeros: gateBiasShape)
-    }
-
-    public struct State: Differentiable {
-        public var cell: Tensor<Scalar>
-        public var hidden: Tensor<Scalar>
-
-        @differentiable
-        public init(cell: Tensor<Scalar>, hidden: Tensor<Scalar>) {
-            self.cell = cell
-            self.hidden = hidden
-        }
-    }
-
-    /// Returns the output obtained from applying the layer to the given input.
-    ///
-    /// - Parameters:
-    ///   - input: The input to the layer.
-    ///   - context: The contextual information for the layer application, e.g. the current learning
-    ///     phase.
-    /// - Returns: The hidden state.
-    @differentiable
-    public func call(_ input: Input) -> Output {
-        let gateInput = input.input.concatenated(with: input.state.hidden, alongAxis: 1)
-
-        let inputGate = sigmoid(matmul(gateInput, inputWeight) + inputBias)
-        let updateGate = tanh(matmul(gateInput, updateWeight) + updateBias)
-        let forgetGate = sigmoid(matmul(gateInput, forgetWeight) + forgetBias)
-        let outputGate = sigmoid(matmul(gateInput, outputWeight) + outputBias)
-
-        let newCellState = input.state.cell * forgetGate + inputGate * updateGate
-        let newHiddenState = tanh(newCellState) * outputGate
-
-        let newState = State(cell: newCellState, hidden: newHiddenState)
-
-        return Output(output: newState, state: newState)
-    }
-}
-
-public struct RNN<Cell: RNNCell>: Layer {
-    public typealias Input = [Cell.TimeStepInput]
-    public typealias Output = [Cell.TimeStepOutput]
-
-    public var cell: Cell
+// /// An input to a recurrent neural network.
+// public struct RNNCellInput<Input: Differentiable, State: Differentiable>: Differentiable {
+//     /// The input at the current time step.
+//     public var input: Input
+//     /// The previous state.
+//     public var state: State
+
+//     @differentiable
+//     public init(input: Input, state: State) {
+//         self.input = input
+//         self.state = state
+//     }
+// }
+
+// /// An output to a recurrent neural network.
+// public struct RNNCellOutput<Output: Differentiable, State: Differentiable>: Differentiable {
+//     /// The output at the current time step.
+//     public var output: Output
+//     /// The current state.
+//     public var state: State
+
+//     @differentiable
+//     public init(output: Output, state: State) {
+//         self.output = output
+//         self.state = state
+//     }
+// }
+
+// /// A recurrent neural network cell.
+// public protocol RNNCell: Layer where Input == RNNCellInput<TimeStepInput, State>,
+//                                      Output == RNNCellOutput<TimeStepOutput, State> {
+//     /// The input at a time step.
+//     associatedtype TimeStepInput: Differentiable
+//     /// The output at a time step.
+//     associatedtype TimeStepOutput: Differentiable
+//     /// The state that may be preserved across time steps.
+//     associatedtype State: Differentiable
+//     /// The zero state.
+//     var zeroState: State { get }
+// }
+
+// public extension RNNCell {
+//     /// Returns the new state obtained from applying the RNN cell to the input at the current time
+//     /// step and the previous state.
+//     ///
+//     /// - Parameters:
+//     ///   - timeStepInput: The input at the current time step.
+//     ///   - previousState: The previous state of the RNN cell.
+//     /// - Returns: The output.
+//     @differentiable
+//     func call(input: TimeStepInput, state: State) -> RNNCellOutput<TimeStepOutput, State> {
+//         return self(RNNCellInput(input: input, state: state))
+//     }
+// }
+
+// /// A Simple RNN Cell.
+// public struct SimpleRNNCell<Scalar: TensorFlowFloatingPoint>: RNNCell, VectorNumeric {
+//     public var weight: Tensor<Scalar>
+//     public var bias: Tensor<Scalar>
+
+//     @noDerivative public var stateShape: TensorShape {
+//         return TensorShape([1, weight.shape[1]])
+//     }
+
+//     public var zeroState: Tensor<Scalar> {
+//         return Tensor(zeros: stateShape)
+//     }
+
+//     public typealias State = Tensor<Scalar>
+//     public typealias TimeStepInput = Tensor<Scalar>
+//     public typealias TimeStepOutput = State
+//     public typealias Input = RNNCellInput<TimeStepInput, State>
+//     public typealias Output = RNNCellOutput<TimeStepOutput, State>
+
+//     /// Creates a `SimpleRNNCell` with the specified input size and hidden state size.
+//     ///
+//     /// - Parameters:
+//     ///   - inputSize: The number of features in 2-D input tensors.
+//     ///   - hiddenSize: The number of features in 2-D hidden states.
+//     ///   - seed: The random seed for initialization. The default value is random.
+//     public init(inputSize: Int, hiddenSize: Int,
+//                 seed: (Int64, Int64) = (Int64.random(in: Int64.min..<Int64.max),
+//                                         Int64.random(in: Int64.min..<Int64.max))) {
+//         let concatenatedInputSize = inputSize + hiddenSize
+//         self.weight = Tensor(glorotUniform: [concatenatedInputSize, hiddenSize],
+//                              seed: seed)
+//         self.bias = Tensor(zeros: [hiddenSize])
+//     }
+
+//     /// Returns the output obtained from applying the layer to the given input.
+//     ///
+//     /// - Parameters:
+//     ///   - input: The input to the layer.
+//     ///   - context: The contextual information for the layer application, e.g. the current learning
+//     ///     phase.
+//     /// - Returns: The hidden state.
+//     @differentiable
+//     public func call(_ input: Input) -> Output {
+//         let concatenatedInput = input.input.concatenated(with: input.state, alongAxis: 1)
+//         let newState = tanh(matmul(concatenatedInput, weight) + bias)
+//         return Output(output: newState, state: newState)
+//     }
+// }
+
+// /// An LSTM Cell.
+// public struct LSTMCell<Scalar: TensorFlowFloatingPoint>: RNNCell, VectorNumeric {
+//     public var inputWeight, updateWeight, forgetWeight, outputWeight: Tensor<Scalar>
+//     public var inputBias, updateBias, forgetBias, outputBias: Tensor<Scalar>
+
+//     @noDerivative public var stateShape: TensorShape {
+//         return TensorShape([1, inputWeight.shape[1]])
+//     }
+
+//     public var zeroState: State {
+//         return State(cell: Tensor(zeros: stateShape), hidden: Tensor(zeros: stateShape))
+//     }
+
+//     public typealias TimeStepInput = Tensor<Scalar>
+//     public typealias TimeStepOutput = State
+//     public typealias Input = RNNCellInput<TimeStepInput, State>
+//     public typealias Output = RNNCellOutput<TimeStepOutput, State>
+
+//     /// Creates a `LSTMCell` with the specified input size and hidden state size.
+//     ///
+//     /// - Parameters:
+//     ///   - inputSize: The number of features in 2-D input tensors.
+//     ///   - hiddenSize: The number of features in 2-D hidden states.
+//     public init(inputSize: Int, hiddenSize: Int,
+//                 seed: (Int64, Int64) = (Int64.random(in: Int64.min..<Int64.max),
+//                                         Int64.random(in: Int64.min..<Int64.max))) {
+//         let concatenatedInputSize = inputSize + hiddenSize
+//         let gateWeightShape = TensorShape([concatenatedInputSize, hiddenSize])
+//         let gateBiasShape = TensorShape([hiddenSize])
+//         self.inputWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
+//         self.inputBias = Tensor(zeros: gateBiasShape)
+//         self.updateWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
+//         self.updateBias = Tensor(zeros: gateBiasShape)
+//         self.forgetWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
+//         self.forgetBias = Tensor(ones: gateBiasShape)
+//         self.outputWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
+//         self.outputBias = Tensor(zeros: gateBiasShape)
+//     }
+
+//     public struct State: Differentiable {
+//         public var cell: Tensor<Scalar>
+//         public var hidden: Tensor<Scalar>
+
+//         @differentiable
+//         public init(cell: Tensor<Scalar>, hidden: Tensor<Scalar>) {
+//             self.cell = cell
+//             self.hidden = hidden
+//         }
+//     }
+
+//     /// Returns the output obtained from applying the layer to the given input.
+//     ///
+//     /// - Parameters:
+//     ///   - input: The input to the layer.
+//     ///   - context: The contextual information for the layer application, e.g. the current learning
+//     ///     phase.
+//     /// - Returns: The hidden state.
+//     @differentiable
+//     public func call(_ input: Input) -> Output {
+//         let gateInput = input.input.concatenated(with: input.state.hidden, alongAxis: 1)
+
+//         let inputGate = sigmoid(matmul(gateInput, inputWeight) + inputBias)
+//         let updateGate = tanh(matmul(gateInput, updateWeight) + updateBias)
+//         let forgetGate = sigmoid(matmul(gateInput, forgetWeight) + forgetBias)
+//         let outputGate = sigmoid(matmul(gateInput, outputWeight) + outputBias)
+
+//         let newCellState = input.state.cell * forgetGate + inputGate * updateGate
+//         let newHiddenState = tanh(newCellState) * outputGate
+
+//         let newState = State(cell: newCellState, hidden: newHiddenState)
+
+//         return Output(output: newState, state: newState)
+//     }
+// }
+
+// public struct RNN<Cell: RNNCell>: Layer {
+//     public typealias Input = [Cell.TimeStepInput]
+//     public typealias Output = [Cell.TimeStepOutput]
+
+//     public var cell: Cell
     
-    public init(_ cell: @autoclosure () -> Cell) {
-        self.cell = cell()
-    }
-
-    @differentiable(wrt: (self, input), vjp: _vjpCall(_:initialState:))
-    public func call(_ input: [Cell.TimeStepInput],
-                     initialState: Cell.State) -> [Cell.TimeStepOutput] {
-        var currentHiddenState = initialState
-        var timeStepOutputs: [Cell.TimeStepOutput] = []
-        for timestep in input {
-            let output = cell(input: timestep, state: currentHiddenState)
-            currentHiddenState = output.state
-            timeStepOutputs.append(output.output)
-        }
-        return timeStepOutputs
-    }
-
-    @usableFromInline
-    internal func _vjpCall(
-        _ inputs: [Cell.TimeStepInput], initialState: Cell.State
-    ) -> ([Cell.TimeStepOutput],
-          (Array<Cell.TimeStepOutput>.CotangentVector)
-              -> (CotangentVector, Array<Cell.TimeStepInput>.CotangentVector)) {
-        let timeStepCount = inputs.count
-        var currentHiddenState = cell.zeroState
-        var timeStepOutputs: [Cell.TimeStepOutput] = []
-        timeStepOutputs.reserveCapacity(timeStepCount)
-        var backpropagators: [Cell.Backpropagator] = []
-        backpropagators.reserveCapacity(timeStepCount)
-        for timestep in inputs {
-            let (output, backpropagator) =
-                cell.appliedForBackpropagation(to: .init(input: timestep,
-                                                         state: currentHiddenState))
-            currentHiddenState = output.state
-            timeStepOutputs.append(output.output)
-            backpropagators.append(backpropagator)
-        }
-        return (timeStepOutputs, { 𝛁outputs in
-            precondition(𝛁outputs.base.count == timeStepCount,
-                         "The number of output gradients must equal the number of time steps")
-            var 𝛁cell = Cell.CotangentVector.zero
-            var 𝛁state = Cell.State.CotangentVector.zero
-            var reversed𝛁inputs: [Cell.TimeStepInput.CotangentVector] = []
-            reversed𝛁inputs.reserveCapacity(timeStepCount)
-            for (𝛁output, backpropagator) in zip(𝛁outputs.base, backpropagators).reversed() {
-                let (new𝛁cell, 𝛁input) = backpropagator(.init(output: 𝛁output, state: 𝛁state))
-                𝛁cell = new𝛁cell
-                𝛁state = 𝛁input.state
-                reversed𝛁inputs.append(𝛁input.input)
-            }
-            return (.init(cell: 𝛁cell), .init(Array(reversed𝛁inputs.reversed())))
-        })
-    }
-
-    @differentiable(wrt: (self, inputs))
-    public func call(_ inputs: [Cell.TimeStepInput]) -> [Cell.TimeStepOutput] {
-        return self(inputs, initialState: cell.zeroState.withoutDerivative())
-    }
-
-    /* TODO: Uncomment once control flow and differentiation through force unwrapping is supported.
-    @differentiable(wrt: (self, inputs))
-    public func lastOutput(from inputs: [Cell.TimeStepInput],
-                           initialState: Cell.State) -> Cell.TimeStepOutput {
-        precondition(!inputs.isEmpty, "inputs cannot be empty")
-        return self(inputs, initialState: initialState).last!
-    }
-
-    @differentiable(wrt: (self, inputs))
-    public func lastOutput(from inputs: [Cell.TimeStepInput]) -> Cell.TimeStepOutput {
-        precondition(!inputs.isEmpty, "inputs cannot be empty")
-        return self(inputs, initialState: cell.zeroState).last!
-    }
-    */
-}
-
-extension RNN: Equatable where Cell: Equatable {}
-extension RNN: AdditiveArithmetic where Cell: AdditiveArithmetic {}
-extension RNN: VectorNumeric where Cell: VectorNumeric {}
-
-public typealias SimpleRNN<Scalar: TensorFlowFloatingPoint> = RNN<SimpleRNNCell<Scalar>>
-public typealias LSTM<Scalar: TensorFlowFloatingPoint> = RNN<LSTMCell<Scalar>>
+//     public init(_ cell: @autoclosure () -> Cell) {
+//         self.cell = cell()
+//     }
+
+//     @differentiable(wrt: (self, input), vjp: _vjpCall(_:initialState:))
+//     public func call(_ input: [Cell.TimeStepInput],
+//                      initialState: Cell.State) -> [Cell.TimeStepOutput] {
+//         var currentHiddenState = initialState
+//         var timeStepOutputs: [Cell.TimeStepOutput] = []
+//         for timestep in input {
+//             let output = cell(input: timestep, state: currentHiddenState)
+//             currentHiddenState = output.state
+//             timeStepOutputs.append(output.output)
+//         }
+//         return timeStepOutputs
+//     }
+
+//     @usableFromInline
+//     internal func _vjpCall(
+//         _ inputs: [Cell.TimeStepInput], initialState: Cell.State
+//     ) -> ([Cell.TimeStepOutput],
+//           (Array<Cell.TimeStepOutput>.CotangentVector)
+//               -> (CotangentVector, Array<Cell.TimeStepInput>.CotangentVector)) {
+//         let timeStepCount = inputs.count
+//         var currentHiddenState = cell.zeroState
+//         var timeStepOutputs: [Cell.TimeStepOutput] = []
+//         timeStepOutputs.reserveCapacity(timeStepCount)
+//         var backpropagators: [Cell.Backpropagator] = []
+//         backpropagators.reserveCapacity(timeStepCount)
+//         for timestep in inputs {
+//             let (output, backpropagator) =
+//                 cell.appliedForBackpropagation(to: .init(input: timestep,
+//                                                          state: currentHiddenState))
+//             currentHiddenState = output.state
+//             timeStepOutputs.append(output.output)
+//             backpropagators.append(backpropagator)
+//         }
+//         return (timeStepOutputs, { 𝛁outputs in
+//             precondition(𝛁outputs.base.count == timeStepCount,
+//                          "The number of output gradients must equal the number of time steps")
+//             var 𝛁cell = Cell.CotangentVector.zero
+//             var 𝛁state = Cell.State.CotangentVector.zero
+//             var reversed𝛁inputs: [Cell.TimeStepInput.CotangentVector] = []
+//             reversed𝛁inputs.reserveCapacity(timeStepCount)
+//             for (𝛁output, backpropagator) in zip(𝛁outputs.base, backpropagators).reversed() {
+//                 let (new𝛁cell, 𝛁input) = backpropagator(.init(output: 𝛁output, state: 𝛁state))
+//                 𝛁cell = new𝛁cell
+//                 𝛁state = 𝛁input.state
+//                 reversed𝛁inputs.append(𝛁input.input)
+//             }
+//             return (.init(cell: 𝛁cell), .init(Array(reversed𝛁inputs.reversed())))
+//         })
+//     }
+
+//     @differentiable(wrt: (self, inputs))
+//     public func call(_ inputs: [Cell.TimeStepInput]) -> [Cell.TimeStepOutput] {
+//         return self(inputs, initialState: cell.zeroState.withoutDerivative())
+//     }
+
+//     /* TODO: Uncomment once control flow and differentiation through force unwrapping is supported.
+//     @differentiable(wrt: (self, inputs))
+//     public func lastOutput(from inputs: [Cell.TimeStepInput],
+//                            initialState: Cell.State) -> Cell.TimeStepOutput {
+//         precondition(!inputs.isEmpty, "inputs cannot be empty")
+//         return self(inputs, initialState: initialState).last!
+//     }
+
+//     @differentiable(wrt: (self, inputs))
+//     public func lastOutput(from inputs: [Cell.TimeStepInput]) -> Cell.TimeStepOutput {
+//         precondition(!inputs.isEmpty, "inputs cannot be empty")
+//         return self(inputs, initialState: cell.zeroState).last!
+//     }
+//     */
+// }
+
+// extension RNN: Equatable where Cell: Equatable {}
+// extension RNN: AdditiveArithmetic where Cell: AdditiveArithmetic {}
+// extension RNN: VectorNumeric where Cell: VectorNumeric {}
+
+// public typealias SimpleRNN<Scalar: TensorFlowFloatingPoint> = RNN<SimpleRNNCell<Scalar>>
+// public typealias LSTM<Scalar: TensorFlowFloatingPoint> = RNN<LSTMCell<Scalar>>
diff --git a/Sources/DeepLearning/Loss.swift b/Sources/DeepLearning/Loss.swift
index fe9400302..fd48febda 100644
--- a/Sources/DeepLearning/Loss.swift
+++ b/Sources/DeepLearning/Loss.swift
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
 /// Computes the mean squared error between predictions and labels.
 ///
diff --git a/Sources/DeepLearning/Operators/Basic.swift b/Sources/DeepLearning/Operators/Basic.swift
index 54f60ec3d..a719604e3 100644
--- a/Sources/DeepLearning/Operators/Basic.swift
+++ b/Sources/DeepLearning/Operators/Basic.swift
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
 //===------------------------------------------------------------------------------------------===//
 // Shape Transformations
@@ -157,7 +155,7 @@ public extension Tensor {
     /// Returns a shape-expanded `Tensor`, with a dimension of 1 inserted at the specified shape
     /// indices.
     @inlinable
-    @differentiable(wrt: self where Scalar : TensorFlowFloatingPoint)
+    @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
     func expandingShape(at axes: Int...) -> Tensor {
         return expandingShape(at: axes)
     }
@@ -351,7 +349,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
 // Broadcasting
 //===------------------------------------------------------------------------------------------===//
 
-// TODO: What about precedence? Also, why is this operator meaningful for broadcasting?
+// TODO: What about precedence? Why is this operator used for broadcasting?
 infix operator .=
 
 public extension Tensor {
@@ -378,18 +376,14 @@ public extension Tensor {
     }
 }
 
-// TODO: Why is this limited only to numeric data types whereas `broadcast` is not?
 public extension Tensor where Scalar: Numeric {
     @inlinable
-    func unbroadcast(toShape otherShape: Tensor<Int32>) -> Tensor {
+    func unbroadcast(toShape otherShape: Tensor<Int32>) -> Tensor<Scalar> {
         let rankDiff = (rankTensor - otherShape.scalarCountTensor).rankLifted()
-        let ones: Tensor<Int32> = Raw.fill(dims: rankDiff, value: Tensor<Int32>(1))
-        let paddedShape = ones ++ otherShape
-        let nonEqualIndices = paddedShape .!= shapeTensor
-        let broadcastIndices = Raw.where_(nonEqualIndices).flattened()
-        let unbroadcasted: Tensor = Raw.sum(
-            self, reductionIndices: Tensor<Int32>(broadcastIndices), keepDims: false)
-        return Raw.reshape(unbroadcasted, shape: otherShape)
+        let ones = Raw.fill(dims: rankDiff, value: Tensor<Int32>(1))
+        let paddedShape = Tensor<Int32>(concatenating: [ones, otherShape], alongAxis: 0)
+        let broadcastIndices = Tensor<Int32>(Raw.where_(paddedShape .!= shapeTensor).flattened())
+        return sum(squeezingAxes: broadcastIndices).reshaped(toShape: otherShape)
     }
 
     @inlinable
diff --git a/Sources/DeepLearning/Operators/Comparison.swift b/Sources/DeepLearning/Operators/Comparison.swift
index 02bf5fadf..985686cf6 100644
--- a/Sources/DeepLearning/Operators/Comparison.swift
+++ b/Sources/DeepLearning/Operators/Comparison.swift
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
 infix operator .<: ComparisonPrecedence
 infix operator .<=: ComparisonPrecedence
@@ -25,123 +23,111 @@ infix operator .!=: ComparisonPrecedence
 
 public extension Tensor where Scalar: Numeric & Comparable {
     /// Computes `lhs < rhs` element-wise and returns a `Tensor` of Boolean /// scalars.
-    @inlinable
+    @inlinable @inline(__always)
     static func .< (lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.less(lhs, rhs)
     }
 
     /// Computes `lhs <= rhs` element-wise and returns a `Tensor` of Boolean scalars.
-    @inlinable
+    @inlinable @inline(__always)
     static func .<= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.lessEqual(lhs, rhs)
     }
 
     /// Computes `lhs > rhs` element-wise and returns a `Tensor` of Boolean scalars.
-    @inlinable
+    @inlinable @inline(__always)
     static func .> (lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.greater(lhs, rhs)
     }
 
     /// Computes `lhs >= rhs` element-wise and returns a `Tensor` of Boolean scalars.
-    @inlinable
+    @inlinable @inline(__always)
     static func .>= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.greaterEqual(lhs, rhs)
     }
 
     /// Computes `lhs < rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.<` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Raw.less(Tensor(lhs), rhs)
     }
 
     /// Computes `lhs <= rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.<=` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .<= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Raw.lessEqual(Tensor(lhs), rhs)
     }
 
     /// Computes `lhs > rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.>` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Raw.greater(Tensor(lhs), rhs)
     }
 
     /// Computes `lhs >= rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.>=` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .>= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Raw.greaterEqual(Tensor(lhs), rhs)
     }
 
     /// Computes `lhs < rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.<` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return Raw.less(lhs, Tensor(rhs))
     }
 
     /// Computes `lhs <= rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.<=` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .<= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return Raw.lessEqual(lhs, Tensor(rhs))
     }
 
     /// Computes `lhs > rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.>` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return Raw.greater(lhs, Tensor(rhs))
     }
 
     /// Computes `lhs >= rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.>=` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return Raw.greaterEqual(lhs, Tensor(rhs))
     }
 }
 
-extension Tensor: Equatable where Scalar: Equatable {
-    @inlinable
-    public static func == (lhs: Tensor, rhs: Tensor) -> Bool {
-        return (lhs .== rhs).all()
-    }
-
-    @inlinable
-    public static func != (lhs: Tensor, rhs: Tensor) -> Bool {
-        return (lhs .== rhs).any()
-    }
-}
-
 extension Tensor: Comparable where Scalar: Numeric & Comparable {
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically less than that of the second argument.
-    @inlinable
+    @inlinable @inline(__always)
     public static func < (lhs: Tensor, rhs: Tensor) -> Bool {
         return (lhs .< rhs).all()
     }
 
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically less than or equal to that of the second argument.
-    @inlinable
+    @inlinable @inline(__always)
     public static func <= (lhs: Tensor, rhs: Tensor) -> Bool {
         return (lhs .<= rhs).all()
     }
 
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically greater than that of the second argument.
-    @inlinable
+    @inlinable @inline(__always)
     public static func > (lhs: Tensor, rhs: Tensor) -> Bool {
         return (lhs .> rhs).all()
     }
 
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically greater than or equal to that of the second argument.
-    @inlinable
+    @inlinable @inline(__always)
     public static func >= (lhs: Tensor, rhs: Tensor) -> Bool {
         return (lhs .>= rhs).all()
     }
@@ -150,28 +136,28 @@ extension Tensor: Comparable where Scalar: Numeric & Comparable {
 public extension Tensor where Scalar: Numeric & Comparable {
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically less than that of the second argument.
-    @inlinable
+    @inlinable @inline(__always)
     static func < (lhs: Tensor, rhs: Scalar) -> Bool {
         return (lhs .< rhs).all()
     }
 
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically less than or equal to that of the second argument.
-    @inlinable
+    @inlinable @inline(__always)
     static func <= (lhs: Tensor, rhs: Scalar) -> Bool {
         return (lhs .<= rhs).all()
     }
 
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically greater than that of the second argument.
-    @inlinable
+    @inlinable @inline(__always)
     static func > (lhs: Tensor, rhs: Scalar) -> Bool {
         return (lhs .> rhs).all()
     }
 
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically greater than or equal to that of the second argument.
-    @inlinable
+    @inlinable @inline(__always)
     static func >= (lhs: Tensor, rhs: Scalar) -> Bool {
         return (lhs .>= rhs).all()
     }
@@ -180,28 +166,28 @@ public extension Tensor where Scalar: Numeric & Comparable {
 public extension Tensor where Scalar: Equatable {
     /// Computes `lhs != rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.==` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .==(lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.equal(lhs, rhs)
     }
 
     /// Computes `lhs != rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.!=` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .!=(lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.notEqual(lhs, rhs)
     }
 
     /// Computes `lhs == rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.==` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .==(lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Tensor(lhs) .== rhs
     }
 
     /// Computes `lhs != rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.!=` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .!=(lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Tensor(lhs) .!= rhs
     }
@@ -209,14 +195,14 @@ public extension Tensor where Scalar: Equatable {
     /// Computes `lhs == rhs` element-wise and returns a `Tensor` of Boolean
     /// scalars.
     /// - Note: `.==` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .==(lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return lhs .== Tensor(rhs)
     }
 
     /// Computes `lhs != rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.!=` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func .!=(lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return lhs .!= Tensor(rhs)
     }
@@ -227,7 +213,7 @@ public extension Tensor where Scalar: Equatable {
 public extension Tensor where Scalar: FloatingPoint & Equatable {
     /// Returns a `Tensor` of Boolean values indicating whether the elements of `self` are
     /// approximately equal to those of `other`.
-    @inlinable
+    @inlinable @inline(__always)
     func elementsApproximatelyEqual(
         _ other: Tensor,
         tolerance: Double = 0.00001
@@ -235,3 +221,12 @@ public extension Tensor where Scalar: FloatingPoint & Equatable {
         return Raw.approximateEqual(self, other, tolerance: tolerance)
     }
 }
+
+public extension StringTensor {
+  /// Computes `self == other` element-wise.
+  /// - Note: `elementsEqual` supports broadcasting.
+  @inlinable @inline(__always)
+  func elementsEqual(_ other: StringTensor) -> Tensor<Bool> {
+    return Raw.equal(self, other)
+  }
+}
diff --git a/Sources/DeepLearning/Operators/Dataset.swift b/Sources/DeepLearning/Operators/Dataset.swift
index 40ca4c7cc..310094291 100644
--- a/Sources/DeepLearning/Operators/Dataset.swift
+++ b/Sources/DeepLearning/Operators/Dataset.swift
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
 /// The default graph seed.
 ///
@@ -74,7 +72,7 @@ public extension Dataset {
   init(elements: Element) {
     // A dataset creation op only runs on TF CPU.
     self.init(_handle: Raw.tensorSliceDataset(
-      components: elements,
+      components: [elements],
       outputShapes: Element._unknownShapeList))
   }
 }
diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/DeepLearning/Operators/Math.swift
index 3319b7e3d..c8590f7dc 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/DeepLearning/Operators/Math.swift
@@ -12,63 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
-#if COMPILING_TENSORFLOW_MODULE
+// #if COMPILING_TENSORFLOW_MODULE
 infix operator .>: ComparisonPrecedence
 infix operator .==: ComparisonPrecedence
-#endif
+// #endif
 
 // TODO:
 // - Consider explicit broadcasting for elementwise binary ops when
 //   scalarization and rank getter are implemented.
 
-//===------------------------------------------------------------------------------------------===//
-// Additive Group
-//===------------------------------------------------------------------------------------------===//
-
-extension Tensor: AdditiveArithmetic where Scalar: Numeric {
-    /// A scalar zero tensor.
-    @inlinable
-    public static var zero: Tensor {
-        return Tensor(zeros: [])
-    }
-
-    /// Adds two tensors and produces their sum.
-    /// - Note: `+` supports broadcasting.
-    @inlinable
-    @differentiable(vjp: _vjpAdd(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
-    public static func + (lhs: Tensor, rhs: Tensor) -> Tensor {
-        return Raw.add(lhs, rhs)
-    }
-
-    /// Subtracts one tensor from another and produces their difference.
-    /// - Note: `-` supports broadcasting.
-    @inlinable
-    @differentiable(vjp: _vjpSubtract(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
-    public static func - (lhs: Tensor, rhs: Tensor) -> Tensor {
-        return Raw.sub(lhs, rhs)
-    }
-}
-
-internal extension Tensor where Scalar: TensorFlowFloatingPoint {
-    @inlinable
-    static func _vjpAdd(lhs: Tensor, rhs: Tensor) -> (Tensor, (Tensor) -> (Tensor, Tensor)) {
-        return (lhs + rhs, { [lhsShape = lhs.shapeTensor, rhsShape = rhs.shapeTensor] v in
-            (v.unbroadcast(toShape: lhsShape), v.unbroadcast(toShape: rhsShape))
-        })
-    }
-
-    @inlinable
-    static func _vjpSubtract(lhs: Tensor, rhs: Tensor) -> (Tensor, (Tensor) -> (Tensor, Tensor)) {
-        return (lhs - rhs, { [lhsShape = lhs.shapeTensor, rhsShape = rhs.shapeTensor] v in
-            (v.unbroadcast(toShape: lhsShape), -v.unbroadcast(toShape: rhsShape))
-        })
-    }
-}
-
 //===------------------------------------------------------------------------------------------===//
 // Vector Space
 //===------------------------------------------------------------------------------------------===//
@@ -93,45 +47,34 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
 
 extension Tensor: ShapedVectorNumeric where Scalar: Numeric {}
 
-extension Tensor: Differentiable where Scalar: TensorFlowFloatingPoint {
-    public typealias TangentVector = Tensor
-    public typealias CotangentVector = Tensor
-    public typealias AllDifferentiableVariables = Tensor
-
-    @inlinable
-    public func tangentVector(from cotangent: CotangentVector) -> TangentVector {
-        return cotangent
-    }
-}
-
 //===------------------------------------------------------------------------------------------===//
 // Additional Element-wise Operators
 //===------------------------------------------------------------------------------------------===//
 
 public extension Tensor where Scalar: Numeric {
     /// Adds the scalar to every scalar of the tensor and produces the sum.
-    @inlinable
+    @inlinable @inline(__always)
     @differentiable(vjp: _vjpAdd(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
     static func + (lhs: Scalar, rhs: Tensor) -> Tensor {
         return Tensor(lhs) + rhs
     }
 
     /// Adds the scalar to every scalar of the tensor and produces the sum.
-    @inlinable
+    @inlinable @inline(__always)
     @differentiable(vjp: _vjpAdd(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
     static func + (lhs: Tensor, rhs: Scalar) -> Tensor {
         return lhs + Tensor(rhs)
     }
 
     /// Subtracts the scalar from every scalar of the tensor and produces the difference.
-    @inlinable
+    @inlinable @inline(__always)
     @differentiable(vjp: _vjpSubtract(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
     static func - (lhs: Scalar, rhs: Tensor) -> Tensor {
         return Tensor(lhs) - rhs
     }
 
     /// Subtracts the scalar from every scalar of the tensor and produces the difference
-    @inlinable
+    @inlinable @inline(__always)
     @differentiable(vjp: _vjpSubtract(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
     static func - (lhs: Tensor, rhs: Scalar) -> Tensor {
         return lhs - Tensor(rhs)
@@ -139,14 +82,14 @@ public extension Tensor where Scalar: Numeric {
 
     /// Adds two tensors and stores the result in the left-hand-side variable.
     /// - Note: `+=` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func += (lhs: inout Tensor, rhs: Tensor) {
         lhs = lhs + rhs
     }
 
     /// Adds the scalar to every scalar of the tensor and stores the result in the left-hand-side
     /// variable.
-    @inlinable
+    @inlinable @inline(__always)
     static func += (lhs: inout Tensor, rhs: Scalar) {
         lhs = lhs + rhs
     }
@@ -154,14 +97,14 @@ public extension Tensor where Scalar: Numeric {
     /// Subtracts the second tensor from the first and stores the result in the left-hand-side
     /// variable.
     /// - Note: `-=` supports broadcasting.
-    @inlinable
+    @inlinable @inline(__always)
     static func -= (lhs: inout Tensor, rhs: Tensor) {
         lhs = lhs - rhs
     }
 
     /// Subtracts the scalar from every scalar of the tensor and stores the result in the
     /// left-hand-side variable.
-    @inlinable
+    @inlinable @inline(__always)
     static func -= (lhs: inout Tensor, rhs: Scalar) {
         lhs = lhs - rhs
     }
@@ -872,7 +815,7 @@ public extension Tensor where Scalar == Bool {
     /// Returns `true` if all scalars are equal to `true`. Otherwise, returns `false`.
     // NOTE: This overload is necessary, otherwise `all()` would refer to the variadic method
     // `all(squeezingAxes:)` with zero indices.
-    @inlinable
+    @inlinable @inline(__always)
     func all() -> Bool {
         let axes = Tensor<Int32>(rangeFrom: 0, to: Int32(rank), stride: 1)
         return Raw.all(self, reductionIndices: axes).scalarized()
@@ -881,7 +824,7 @@ public extension Tensor where Scalar == Bool {
     /// Returns `true` if any scalars are equal to `true`. Otherwise, returns `false`.
     // NOTE: This overload is necessary, otherwise `any()` would refer to the variadic method
     // `any(squeezingAxes:)` with zero indices.
-    @inlinable
+    @inlinable @inline(__always)
     func any() -> Bool {
         let axes = Tensor<Int32>(rangeFrom: 0, to: Int32(rank), stride: 1)
         return Raw.any(self, reductionIndices: axes).scalarized()
@@ -891,7 +834,7 @@ public extension Tensor where Scalar == Bool {
     /// removed.
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
-    @inlinable
+    @inlinable @inline(__always)
     func all(squeezingAxes axes: Int...) -> Tensor {
         let axes = axes.map(Int32.init)
         return Raw.all(self, reductionIndices: Tensor<Int32>(axes), keepDims: false)
@@ -901,7 +844,7 @@ public extension Tensor where Scalar == Bool {
     /// removed.
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
-    @inlinable
+    @inlinable @inline(__always)
     func any(squeezingAxes axes: Int...) -> Tensor {
         let axes = axes.map(Int32.init)
         return Raw.any(self, reductionIndices: Tensor<Int32>(axes), keepDims: false)
@@ -911,7 +854,7 @@ public extension Tensor where Scalar == Bool {
     /// retained with value 1.
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
-    @inlinable
+    @inlinable @inline(__always)
     func all(alongAxes axes: Int...) -> Tensor {
         let axes = axes.map(Int32.init)
         return Raw.all(self, reductionIndices: Tensor<Int32>(axes), keepDims: true)
@@ -921,7 +864,7 @@ public extension Tensor where Scalar == Bool {
     /// dimensions are retained with value 1.
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
-    @inlinable
+    @inlinable @inline(__always)
     func any(alongAxes axes: Int...) -> Tensor {
         let axes = axes.map(Int32.init)
         return Raw.any(self, reductionIndices: Tensor<Int32>(axes), keepDims: true)
@@ -1095,20 +1038,16 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
   func _vjpMinOrMax(squeezingAxes axes: Tensor<Int32>) -> (Tensor, (Tensor) -> Tensor) {
     let result = max(squeezingAxes: axes)
     return (result, { v in
-      var y = result
-      var gradient = v
-      for i in axes.array.scalars {
-        y = y.expandingShape(at: Int(i))
-        gradient = gradient.expandingShape(at: Int(i))
-      }
+      let yUnsqueezed = result.expandingShape(at: axes.scalars.map { Int($0) })
+      let gradientUnsqueezed = v.expandingShape(at: axes.scalars.map { Int($0) })
 
       // Compute the number of selected (maximum or minimum) elements in each reduction dimension.
       // If there are multiple minimum or maximum elements then the gradient will be divided between
       // them.
-      let indicators = Tensor(y .== self)
+      let indicators = Tensor(yUnsqueezed .== self)
       let selectedCount = indicators.sum(alongAxes: axes)
 
-      return gradient.broadcast(toShape: self.shapeTensor) * indicators / selectedCount
+      return gradientUnsqueezed.broadcast(toShape: self.shapeTensor) * indicators / selectedCount
     })
   }
 
@@ -1417,11 +1356,10 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
     @inlinable
     func _vjpSum(squeezingAxes axes: Tensor<Int32>) -> (Tensor, (Tensor) -> Tensor) {
         let value = sum(squeezingAxes: axes)
-        return (value, { [shape = shapeTensor] in
-            var result = $0
-            for i in axes.array.scalars { result = result.expandingShape(at: Int(i)) }
-            return result.broadcast(toShape: shape)
-        })
+        return (value, { [shape = shapeTensor] v in
+	      let unsqueezed = v.expandingShape(at: axes.scalars.map { Int($0) })
+	      return unsqueezed.broadcast(toShape: shape)
+	    })
     }
 
     @inlinable
@@ -1435,11 +1373,10 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
     func _vjpMean(squeezingAxes axes: Tensor<Int32>) -> (Tensor, (Tensor) -> Tensor) {
         let value = mean(squeezingAxes: axes)
         let count = Raw.gather(params: shapeTensor, indices: axes).product()
-        return (value, { [shape = shapeTensor] in 
-            var result = $0
-            for i in axes.array.scalars { result = result.expandingShape(at: Int(i)) }
-            return result.broadcast(toShape: shape) / Tensor(count)
-        })
+        return (value, { [shape = shapeTensor] v in
+	      let unsqueezed = v.expandingShape(at: axes.scalars.map { Int($0) })
+	      return unsqueezed.broadcast(toShape: shape) / Tensor(count)
+	    })
     }
 }
 
@@ -1532,7 +1469,7 @@ public extension Tensor where Scalar: TensorFlowFloatingPoint {
 //===------------------------------------------------------------------------------------------===//
 
 /// Performs matrix multiplication with another tensor and produces the result.
-@inlinable
+@inlinable @inline(__always)
 @differentiable(vjp: _vjpMatmul(_:_:) where Scalar: TensorFlowFloatingPoint)
 public func matmul<Scalar: Numeric>(
     _ lhs: Tensor<Scalar>,
@@ -1562,7 +1499,7 @@ public extension Tensor where Scalar: Numeric {
     // After AD can differentiate generic methods, remove the custom VJP.
 
     /// Performs matrix multiplication between two tensors and produces the result.
-    @inlinable
+    @inlinable @inline(__always)
     @differentiable(vjp: _vjpMatmulOperator(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
     static func • (lhs: Tensor, rhs: Tensor) -> Tensor {
         return matmul(lhs, rhs)
diff --git a/Sources/DeepLearning/Operators/NN.swift b/Sources/DeepLearning/Operators/NN.swift
index c461a910b..8002eccba 100644
--- a/Sources/DeepLearning/Operators/NN.swift
+++ b/Sources/DeepLearning/Operators/NN.swift
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
 //===------------------------------------------------------------------------------------------===//
 // Normalization
diff --git a/Sources/DeepLearning/Optimizer.swift b/Sources/DeepLearning/Optimizer.swift
index 440a691e0..bbd0b95a2 100644
--- a/Sources/DeepLearning/Optimizer.swift
+++ b/Sources/DeepLearning/Optimizer.swift
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
 /// A machine learning optimizer.
 ///
diff --git a/Sources/DeepLearning/PythonConversion.swift b/Sources/DeepLearning/PythonConversion.swift
index f5601ae6d..2c1a6a377 100644
--- a/Sources/DeepLearning/PythonConversion.swift
+++ b/Sources/DeepLearning/PythonConversion.swift
@@ -12,9 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
 #if canImport(Python)
 import Python
diff --git a/Sources/DeepLearning/Tensors.swift b/Sources/DeepLearning/Tensor.swift
similarity index 78%
rename from Sources/DeepLearning/Tensors.swift
rename to Sources/DeepLearning/Tensor.swift
index 7be5c5c9d..20647a905 100644
--- a/Sources/DeepLearning/Tensors.swift
+++ b/Sources/DeepLearning/Tensor.swift
@@ -12,46 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if !COMPILING_TENSORFLOW_MODULE
-import TensorFlow
-#endif
+import TensorFlowCore
 
-#if COMPILING_TENSORFLOW_MODULE
+// #if COMPILING_TENSORFLOW_MODULE
 infix operator .==: ComparisonPrecedence
-#endif
-
-//===------------------------------------------------------------------------------------------===//
-// Tensor Properties
-//===------------------------------------------------------------------------------------------===//
-
-public extension Tensor {
-  /// The rank of the tensor, represented as a `Tensor<Int32>`.
-  @inlinable
-  var rankTensor: Tensor<Int32> {
-    @_semantics("autodiff.nonvarying")
-    get {
-        return Raw.rank(self)
-    }
-  }
-
-  /// The dimensions of the tensor, represented as a `Tensor<Int32>`.
-  @inlinable
-  var shapeTensor: Tensor<Int32> {
-    @_semantics("autodiff.nonvarying")
-    get {
-        return Raw.shape(self)
-    }
-  }
-
-  /// The number of scalars in the tensor, represented as a `Tensor<Int32>`.
-  @inlinable
-  var scalarCountTensor: Tensor<Int32> {
-    @_semantics("autodiff.nonvarying")
-    get {
-        return Raw.size(self)
-    }
-  }
-}
+// #endif
 
 //===------------------------------------------------------------------------------------------===//
 // Description and Visualization

From 93b5420e8a472e6774e9dd22d5bd2ea0d27593ed Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Fri, 26 Apr 2019 03:02:11 -0400
Subject: [PATCH 12/55] Made all tests succeed.

---
 .../DeepLearning/DifferentialOperators.swift  |  78 +--
 Sources/DeepLearning/Initializers.swift       |  35 +-
 Sources/DeepLearning/Layer.swift              | 530 +++++++++---------
 Sources/DeepLearning/Operators/Basic.swift    |   8 +-
 Sources/DeepLearning/Operators/Math.swift     |  22 +-
 Sources/DeepLearning/Tensor.swift             |   2 -
 Tests/DeepLearningTests/LayerTests.swift      |  32 +-
 .../OperatorTests/MathTests.swift             |  21 +-
 Tests/DeepLearningTests/TensorTests.swift     |   8 +-
 9 files changed, 394 insertions(+), 342 deletions(-)

diff --git a/Sources/DeepLearning/DifferentialOperators.swift b/Sources/DeepLearning/DifferentialOperators.swift
index e499e737e..9fade54b9 100644
--- a/Sources/DeepLearning/DifferentialOperators.swift
+++ b/Sources/DeepLearning/DifferentialOperators.swift
@@ -52,9 +52,9 @@ public extension Differentiable {
     }
 }
 
-//===------------------------------------------------------------------------------------------===//
+// ===------------------------------------------------------------------------------------------===//
 // Free-Function-Style Differential Operators
-//===------------------------------------------------------------------------------------------===//
+// ===------------------------------------------------------------------------------------------===//
 
 // Value with gradient
 
@@ -79,17 +79,17 @@ public func valueWithGradient<T, U, R>(
     return (y, pullback(Tensor<R>(1)))
 }
 
-@inlinable
-public func valueWithGradient<T, U, V, R>(
-    at x: T,
-    _ y: U,
-    _ z: V,
-    in f: @differentiable (T, U, V) -> Tensor<R>
-) -> (value: Tensor<R>, gradient: (T.CotangentVector, U.CotangentVector, V.CotangentVector))
-  where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint {
-  let (y, pullback) = valueWithPullback(at: x, y, z, in: f)
-  return (y, pullback(Tensor<R>(1)))
-}
+// @inlinable
+// public func valueWithGradient<T, U, V, R>(
+//     at x: T,
+//     _ y: U,
+//     _ z: V,
+//     in f: @differentiable (T, U, V) -> Tensor<R>
+// ) -> (value: Tensor<R>, gradient: (T.CotangentVector, U.CotangentVector, V.CotangentVector))
+//   where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint {
+//   let (y, pullback) = valueWithPullback(at: x, y, z, in: f)
+//   return (y, pullback(Tensor<R>(1)))
+// }
 
 // Value with gradient (curried)
 
@@ -109,15 +109,15 @@ public func valueWithGradient<T, U, R>(
   return { x, y in valueWithGradient(at: x, y, in: f) }
 }
 
-@inlinable
-public func valueWithGradient<T, U, V, R>(
-    of f: @escaping @differentiable (T, U, V) -> Tensor<R>
-) -> (T, U, V) -> (
-    value: Tensor<R>,
-    gradient: (T.CotangentVector, U.CotangentVector, V.CotangentVector))
-    where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint {
-  return { x, y, z in valueWithGradient(at: x, y, z, in: f) }
-}
+// @inlinable
+// public func valueWithGradient<T, U, V, R>(
+//     of f: @escaping @differentiable (T, U, V) -> Tensor<R>
+// ) -> (T, U, V) -> (
+//     value: Tensor<R>,
+//     gradient: (T.CotangentVector, U.CotangentVector, V.CotangentVector))
+//     where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint {
+//   return { x, y, z in valueWithGradient(at: x, y, z, in: f) }
+// }
 
 // Gradient
 
@@ -139,16 +139,16 @@ public func gradient<T, U, R>(
     return pullback(at: x, y, in: f)(Tensor<R>(1))
 }
 
-@inlinable
-public func gradient<T, U, V, R>(
-    at x: T,
-    _ y: U,
-    _ z: V,
-    in f: @differentiable (T, U, V) -> Tensor<R>
-) -> (T.CotangentVector, U.CotangentVector, V.CotangentVector)
-    where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint {
-    return pullback(at: x, y, z, in: f)(Tensor<R>(1))
-}
+// @inlinable
+// public func gradient<T, U, V, R>(
+//     at x: T,
+//     _ y: U,
+//     _ z: V,
+//     in f: @differentiable (T, U, V) -> Tensor<R>
+// ) -> (T.CotangentVector, U.CotangentVector, V.CotangentVector)
+//     where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint {
+//     return pullback(at: x, y, z, in: f)(Tensor<R>(1))
+// }
 
 // Gradient (curried)
 
@@ -167,10 +167,10 @@ public func gradient<T, U, R>(
     return { x, y in gradient(at: x, y, in: f) }
 }
 
-@inlinable
-public func gradient<T, U, V, R>(
-    of f: @escaping @differentiable (T, U, V) -> Tensor<R>
-) -> (T, U, V) -> (T.CotangentVector, U.CotangentVector, V.CotangentVector)
-    where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint {
-    return { x, y, z in gradient(at: x, y, z, in: f) }
-}
+// @inlinable
+// public func gradient<T, U, V, R>(
+//     of f: @escaping @differentiable (T, U, V) -> Tensor<R>
+// ) -> (T, U, V) -> (T.CotangentVector, U.CotangentVector, V.CotangentVector)
+//     where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint {
+//     return { x, y, z in gradient(at: x, y, z, in: f) }
+// }
diff --git a/Sources/DeepLearning/Initializers.swift b/Sources/DeepLearning/Initializers.swift
index 6a35ef3f6..330e49453 100644
--- a/Sources/DeepLearning/Initializers.swift
+++ b/Sources/DeepLearning/Initializers.swift
@@ -33,8 +33,7 @@ public extension Tensor {
     ///   - repeatedValue: The scalar value to repeat.
     ///   - shape: The dimensions of the tensor.
     @inlinable @inline(__always)
-    @differentiable(
-        vjp: _vjpInit(repeating:shape:) where Scalar: TensorFlowFloatingPoint)
+    @differentiable(vjp: _vjpInit(repeating:shape:) where Scalar: TensorFlowFloatingPoint)
     init(repeating repeatedValue: Scalar, shape: TensorShape) {
         self = Raw.fill(
             dims: Tensor<Int32>(shape.dimensions.map(Int32.init)),
@@ -241,6 +240,24 @@ public extension Tensor where Scalar: Numeric {
         self.init(repeating: 1, shape: shape)
     }
 
+    /// Creates a tensor with all scalars set to zero that has the same shape and type as the provided
+    /// tensor.
+    ///
+    /// - Parameter other: Tensor whose shape and data type to use.
+    @inlinable @inline(__always)
+    init(zerosLike other: Tensor) {
+        self = Raw.zerosLike(other)
+    }
+
+    /// Creates a tensor with all scalars set to one that has the same shape and type as the provided
+    /// tensor.
+    ///
+    /// - Parameter other: Tensor whose shape and data type to use.
+    @inlinable @inline(__always)
+    init(onesLike other: Tensor) {
+        self = Raw.onesLike(other)
+    }
+
     /// Creates a 1-D tensor representing a sequence from a starting value to, but not including, 
     /// an end value, stepping by the specified amount.
     ///
@@ -256,6 +273,20 @@ public extension Tensor where Scalar: Numeric {
         self = Raw.range(start: Tensor(start), limit: Tensor(end), delta: Tensor(stride))
     }
 
+    /// Creates a 1-D tensor representing a sequence from a starting value to, but not including, an
+    /// end value, stepping by the specified amount.
+    ///
+    /// - Parameters:
+    ///   - start: The starting value to use for the sequence. If the sequence contains any values,
+    ///     the first one is `start`.
+    ///   - end: An end value to limit the sequence. `end` is never an element of the resulting
+    ///     sequence.
+    ///   - stride: The amount to step by with each iteration. `stride` must be positive.
+    @inlinable @inline(__always)
+    init(rangeFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, stride: Tensor<Scalar>) {
+        self = Raw.range(start: start, limit: end, delta: stride)
+    }
+
     /// Creates a one-hot tensor at given indices. The locations represented by
     /// `indices` take value `onValue` (`1` by default), while all other locations
     /// take value `offValue` (`0` by default). If the input `indices` is rank
diff --git a/Sources/DeepLearning/Layer.swift b/Sources/DeepLearning/Layer.swift
index 81eb59444..4f3a5b9e6 100644
--- a/Sources/DeepLearning/Layer.swift
+++ b/Sources/DeepLearning/Layer.swift
@@ -1224,269 +1224,269 @@ public struct Reshape<Scalar: TensorFlowFloatingPoint>: Layer {
     }
 }
 
-// /// An input to a recurrent neural network.
-// public struct RNNCellInput<Input: Differentiable, State: Differentiable>: Differentiable {
-//     /// The input at the current time step.
-//     public var input: Input
-//     /// The previous state.
-//     public var state: State
-
-//     @differentiable
-//     public init(input: Input, state: State) {
-//         self.input = input
-//         self.state = state
-//     }
-// }
-
-// /// An output to a recurrent neural network.
-// public struct RNNCellOutput<Output: Differentiable, State: Differentiable>: Differentiable {
-//     /// The output at the current time step.
-//     public var output: Output
-//     /// The current state.
-//     public var state: State
-
-//     @differentiable
-//     public init(output: Output, state: State) {
-//         self.output = output
-//         self.state = state
-//     }
-// }
-
-// /// A recurrent neural network cell.
-// public protocol RNNCell: Layer where Input == RNNCellInput<TimeStepInput, State>,
-//                                      Output == RNNCellOutput<TimeStepOutput, State> {
-//     /// The input at a time step.
-//     associatedtype TimeStepInput: Differentiable
-//     /// The output at a time step.
-//     associatedtype TimeStepOutput: Differentiable
-//     /// The state that may be preserved across time steps.
-//     associatedtype State: Differentiable
-//     /// The zero state.
-//     var zeroState: State { get }
-// }
-
-// public extension RNNCell {
-//     /// Returns the new state obtained from applying the RNN cell to the input at the current time
-//     /// step and the previous state.
-//     ///
-//     /// - Parameters:
-//     ///   - timeStepInput: The input at the current time step.
-//     ///   - previousState: The previous state of the RNN cell.
-//     /// - Returns: The output.
-//     @differentiable
-//     func call(input: TimeStepInput, state: State) -> RNNCellOutput<TimeStepOutput, State> {
-//         return self(RNNCellInput(input: input, state: state))
-//     }
-// }
-
-// /// A Simple RNN Cell.
-// public struct SimpleRNNCell<Scalar: TensorFlowFloatingPoint>: RNNCell, VectorNumeric {
-//     public var weight: Tensor<Scalar>
-//     public var bias: Tensor<Scalar>
-
-//     @noDerivative public var stateShape: TensorShape {
-//         return TensorShape([1, weight.shape[1]])
-//     }
-
-//     public var zeroState: Tensor<Scalar> {
-//         return Tensor(zeros: stateShape)
-//     }
-
-//     public typealias State = Tensor<Scalar>
-//     public typealias TimeStepInput = Tensor<Scalar>
-//     public typealias TimeStepOutput = State
-//     public typealias Input = RNNCellInput<TimeStepInput, State>
-//     public typealias Output = RNNCellOutput<TimeStepOutput, State>
-
-//     /// Creates a `SimpleRNNCell` with the specified input size and hidden state size.
-//     ///
-//     /// - Parameters:
-//     ///   - inputSize: The number of features in 2-D input tensors.
-//     ///   - hiddenSize: The number of features in 2-D hidden states.
-//     ///   - seed: The random seed for initialization. The default value is random.
-//     public init(inputSize: Int, hiddenSize: Int,
-//                 seed: (Int64, Int64) = (Int64.random(in: Int64.min..<Int64.max),
-//                                         Int64.random(in: Int64.min..<Int64.max))) {
-//         let concatenatedInputSize = inputSize + hiddenSize
-//         self.weight = Tensor(glorotUniform: [concatenatedInputSize, hiddenSize],
-//                              seed: seed)
-//         self.bias = Tensor(zeros: [hiddenSize])
-//     }
-
-//     /// Returns the output obtained from applying the layer to the given input.
-//     ///
-//     /// - Parameters:
-//     ///   - input: The input to the layer.
-//     ///   - context: The contextual information for the layer application, e.g. the current learning
-//     ///     phase.
-//     /// - Returns: The hidden state.
-//     @differentiable
-//     public func call(_ input: Input) -> Output {
-//         let concatenatedInput = input.input.concatenated(with: input.state, alongAxis: 1)
-//         let newState = tanh(matmul(concatenatedInput, weight) + bias)
-//         return Output(output: newState, state: newState)
-//     }
-// }
-
-// /// An LSTM Cell.
-// public struct LSTMCell<Scalar: TensorFlowFloatingPoint>: RNNCell, VectorNumeric {
-//     public var inputWeight, updateWeight, forgetWeight, outputWeight: Tensor<Scalar>
-//     public var inputBias, updateBias, forgetBias, outputBias: Tensor<Scalar>
-
-//     @noDerivative public var stateShape: TensorShape {
-//         return TensorShape([1, inputWeight.shape[1]])
-//     }
-
-//     public var zeroState: State {
-//         return State(cell: Tensor(zeros: stateShape), hidden: Tensor(zeros: stateShape))
-//     }
-
-//     public typealias TimeStepInput = Tensor<Scalar>
-//     public typealias TimeStepOutput = State
-//     public typealias Input = RNNCellInput<TimeStepInput, State>
-//     public typealias Output = RNNCellOutput<TimeStepOutput, State>
-
-//     /// Creates a `LSTMCell` with the specified input size and hidden state size.
-//     ///
-//     /// - Parameters:
-//     ///   - inputSize: The number of features in 2-D input tensors.
-//     ///   - hiddenSize: The number of features in 2-D hidden states.
-//     public init(inputSize: Int, hiddenSize: Int,
-//                 seed: (Int64, Int64) = (Int64.random(in: Int64.min..<Int64.max),
-//                                         Int64.random(in: Int64.min..<Int64.max))) {
-//         let concatenatedInputSize = inputSize + hiddenSize
-//         let gateWeightShape = TensorShape([concatenatedInputSize, hiddenSize])
-//         let gateBiasShape = TensorShape([hiddenSize])
-//         self.inputWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
-//         self.inputBias = Tensor(zeros: gateBiasShape)
-//         self.updateWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
-//         self.updateBias = Tensor(zeros: gateBiasShape)
-//         self.forgetWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
-//         self.forgetBias = Tensor(ones: gateBiasShape)
-//         self.outputWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
-//         self.outputBias = Tensor(zeros: gateBiasShape)
-//     }
-
-//     public struct State: Differentiable {
-//         public var cell: Tensor<Scalar>
-//         public var hidden: Tensor<Scalar>
-
-//         @differentiable
-//         public init(cell: Tensor<Scalar>, hidden: Tensor<Scalar>) {
-//             self.cell = cell
-//             self.hidden = hidden
-//         }
-//     }
-
-//     /// Returns the output obtained from applying the layer to the given input.
-//     ///
-//     /// - Parameters:
-//     ///   - input: The input to the layer.
-//     ///   - context: The contextual information for the layer application, e.g. the current learning
-//     ///     phase.
-//     /// - Returns: The hidden state.
-//     @differentiable
-//     public func call(_ input: Input) -> Output {
-//         let gateInput = input.input.concatenated(with: input.state.hidden, alongAxis: 1)
-
-//         let inputGate = sigmoid(matmul(gateInput, inputWeight) + inputBias)
-//         let updateGate = tanh(matmul(gateInput, updateWeight) + updateBias)
-//         let forgetGate = sigmoid(matmul(gateInput, forgetWeight) + forgetBias)
-//         let outputGate = sigmoid(matmul(gateInput, outputWeight) + outputBias)
-
-//         let newCellState = input.state.cell * forgetGate + inputGate * updateGate
-//         let newHiddenState = tanh(newCellState) * outputGate
-
-//         let newState = State(cell: newCellState, hidden: newHiddenState)
-
-//         return Output(output: newState, state: newState)
-//     }
-// }
-
-// public struct RNN<Cell: RNNCell>: Layer {
-//     public typealias Input = [Cell.TimeStepInput]
-//     public typealias Output = [Cell.TimeStepOutput]
-
-//     public var cell: Cell
+/// An input to a recurrent neural network.
+public struct RNNCellInput<Input: Differentiable, State: Differentiable>: Differentiable {
+    /// The input at the current time step.
+    public var input: Input
+    /// The previous state.
+    public var state: State
+
+    @differentiable
+    public init(input: Input, state: State) {
+        self.input = input
+        self.state = state
+    }
+}
+
+/// An output to a recurrent neural network.
+public struct RNNCellOutput<Output: Differentiable, State: Differentiable>: Differentiable {
+    /// The output at the current time step.
+    public var output: Output
+    /// The current state.
+    public var state: State
+
+    @differentiable
+    public init(output: Output, state: State) {
+        self.output = output
+        self.state = state
+    }
+}
+
+/// A recurrent neural network cell.
+public protocol RNNCell: Layer where Input == RNNCellInput<TimeStepInput, State>,
+                                     Output == RNNCellOutput<TimeStepOutput, State> {
+    /// The input at a time step.
+    associatedtype TimeStepInput: Differentiable
+    /// The output at a time step.
+    associatedtype TimeStepOutput: Differentiable
+    /// The state that may be preserved across time steps.
+    associatedtype State: Differentiable
+    /// The zero state.
+    var zeroState: State { get }
+}
+
+public extension RNNCell {
+    /// Returns the new state obtained from applying the RNN cell to the input at the current time
+    /// step and the previous state.
+    ///
+    /// - Parameters:
+    ///   - timeStepInput: The input at the current time step.
+    ///   - previousState: The previous state of the RNN cell.
+    /// - Returns: The output.
+    @differentiable
+    func call(input: TimeStepInput, state: State) -> RNNCellOutput<TimeStepOutput, State> {
+        return self(RNNCellInput(input: input, state: state))
+    }
+}
+
+/// A Simple RNN Cell.
+public struct SimpleRNNCell<Scalar: TensorFlowFloatingPoint>: RNNCell, VectorNumeric {
+    public var weight: Tensor<Scalar>
+    public var bias: Tensor<Scalar>
+
+    @noDerivative public var stateShape: TensorShape {
+        return TensorShape([1, weight.shape[1]])
+    }
+
+    public var zeroState: Tensor<Scalar> {
+        return Tensor(zeros: stateShape)
+    }
+
+    public typealias State = Tensor<Scalar>
+    public typealias TimeStepInput = Tensor<Scalar>
+    public typealias TimeStepOutput = State
+    public typealias Input = RNNCellInput<TimeStepInput, State>
+    public typealias Output = RNNCellOutput<TimeStepOutput, State>
+
+    /// Creates a `SimpleRNNCell` with the specified input size and hidden state size.
+    ///
+    /// - Parameters:
+    ///   - inputSize: The number of features in 2-D input tensors.
+    ///   - hiddenSize: The number of features in 2-D hidden states.
+    ///   - seed: The random seed for initialization. The default value is random.
+    public init(inputSize: Int, hiddenSize: Int,
+                seed: (Int64, Int64) = (Int64.random(in: Int64.min..<Int64.max),
+                                        Int64.random(in: Int64.min..<Int64.max))) {
+        let concatenatedInputSize = inputSize + hiddenSize
+        self.weight = Tensor(glorotUniform: [concatenatedInputSize, hiddenSize],
+                             seed: seed)
+        self.bias = Tensor(zeros: [hiddenSize])
+    }
+
+    /// Returns the output obtained from applying the layer to the given input.
+    ///
+    /// - Parameters:
+    ///   - input: The input to the layer.
+    ///   - context: The contextual information for the layer application, e.g. the current learning
+    ///     phase.
+    /// - Returns: The hidden state.
+    @differentiable
+    public func call(_ input: Input) -> Output {
+        let concatenatedInput = input.input.concatenated(with: input.state, alongAxis: 1)
+        let newState = tanh(matmul(concatenatedInput, weight) + bias)
+        return Output(output: newState, state: newState)
+    }
+}
+
+/// An LSTM Cell.
+public struct LSTMCell<Scalar: TensorFlowFloatingPoint>: RNNCell, VectorNumeric {
+    public var inputWeight, updateWeight, forgetWeight, outputWeight: Tensor<Scalar>
+    public var inputBias, updateBias, forgetBias, outputBias: Tensor<Scalar>
+
+    @noDerivative public var stateShape: TensorShape {
+        return TensorShape([1, inputWeight.shape[1]])
+    }
+
+    public var zeroState: State {
+        return State(cell: Tensor(zeros: stateShape), hidden: Tensor(zeros: stateShape))
+    }
+
+    public typealias TimeStepInput = Tensor<Scalar>
+    public typealias TimeStepOutput = State
+    public typealias Input = RNNCellInput<TimeStepInput, State>
+    public typealias Output = RNNCellOutput<TimeStepOutput, State>
+
+    /// Creates a `LSTMCell` with the specified input size and hidden state size.
+    ///
+    /// - Parameters:
+    ///   - inputSize: The number of features in 2-D input tensors.
+    ///   - hiddenSize: The number of features in 2-D hidden states.
+    public init(inputSize: Int, hiddenSize: Int,
+                seed: (Int64, Int64) = (Int64.random(in: Int64.min..<Int64.max),
+                                        Int64.random(in: Int64.min..<Int64.max))) {
+        let concatenatedInputSize = inputSize + hiddenSize
+        let gateWeightShape = TensorShape([concatenatedInputSize, hiddenSize])
+        let gateBiasShape = TensorShape([hiddenSize])
+        self.inputWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
+        self.inputBias = Tensor(zeros: gateBiasShape)
+        self.updateWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
+        self.updateBias = Tensor(zeros: gateBiasShape)
+        self.forgetWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
+        self.forgetBias = Tensor(ones: gateBiasShape)
+        self.outputWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
+        self.outputBias = Tensor(zeros: gateBiasShape)
+    }
+
+    public struct State: Differentiable {
+        public var cell: Tensor<Scalar>
+        public var hidden: Tensor<Scalar>
+
+        @differentiable
+        public init(cell: Tensor<Scalar>, hidden: Tensor<Scalar>) {
+            self.cell = cell
+            self.hidden = hidden
+        }
+    }
+
+    /// Returns the output obtained from applying the layer to the given input.
+    ///
+    /// - Parameters:
+    ///   - input: The input to the layer.
+    ///   - context: The contextual information for the layer application, e.g. the current learning
+    ///     phase.
+    /// - Returns: The hidden state.
+    @differentiable
+    public func call(_ input: Input) -> Output {
+        let gateInput = input.input.concatenated(with: input.state.hidden, alongAxis: 1)
+
+        let inputGate = sigmoid(matmul(gateInput, inputWeight) + inputBias)
+        let updateGate = tanh(matmul(gateInput, updateWeight) + updateBias)
+        let forgetGate = sigmoid(matmul(gateInput, forgetWeight) + forgetBias)
+        let outputGate = sigmoid(matmul(gateInput, outputWeight) + outputBias)
+
+        let newCellState = input.state.cell * forgetGate + inputGate * updateGate
+        let newHiddenState = tanh(newCellState) * outputGate
+
+        let newState = State(cell: newCellState, hidden: newHiddenState)
+
+        return Output(output: newState, state: newState)
+    }
+}
+
+public struct RNN<Cell: RNNCell>: Layer {
+    public typealias Input = [Cell.TimeStepInput]
+    public typealias Output = [Cell.TimeStepOutput]
+
+    public var cell: Cell
     
-//     public init(_ cell: @autoclosure () -> Cell) {
-//         self.cell = cell()
-//     }
-
-//     @differentiable(wrt: (self, input), vjp: _vjpCall(_:initialState:))
-//     public func call(_ input: [Cell.TimeStepInput],
-//                      initialState: Cell.State) -> [Cell.TimeStepOutput] {
-//         var currentHiddenState = initialState
-//         var timeStepOutputs: [Cell.TimeStepOutput] = []
-//         for timestep in input {
-//             let output = cell(input: timestep, state: currentHiddenState)
-//             currentHiddenState = output.state
-//             timeStepOutputs.append(output.output)
-//         }
-//         return timeStepOutputs
-//     }
-
-//     @usableFromInline
-//     internal func _vjpCall(
-//         _ inputs: [Cell.TimeStepInput], initialState: Cell.State
-//     ) -> ([Cell.TimeStepOutput],
-//           (Array<Cell.TimeStepOutput>.CotangentVector)
-//               -> (CotangentVector, Array<Cell.TimeStepInput>.CotangentVector)) {
-//         let timeStepCount = inputs.count
-//         var currentHiddenState = cell.zeroState
-//         var timeStepOutputs: [Cell.TimeStepOutput] = []
-//         timeStepOutputs.reserveCapacity(timeStepCount)
-//         var backpropagators: [Cell.Backpropagator] = []
-//         backpropagators.reserveCapacity(timeStepCount)
-//         for timestep in inputs {
-//             let (output, backpropagator) =
-//                 cell.appliedForBackpropagation(to: .init(input: timestep,
-//                                                          state: currentHiddenState))
-//             currentHiddenState = output.state
-//             timeStepOutputs.append(output.output)
-//             backpropagators.append(backpropagator)
-//         }
-//         return (timeStepOutputs, { 𝛁outputs in
-//             precondition(𝛁outputs.base.count == timeStepCount,
-//                          "The number of output gradients must equal the number of time steps")
-//             var 𝛁cell = Cell.CotangentVector.zero
-//             var 𝛁state = Cell.State.CotangentVector.zero
-//             var reversed𝛁inputs: [Cell.TimeStepInput.CotangentVector] = []
-//             reversed𝛁inputs.reserveCapacity(timeStepCount)
-//             for (𝛁output, backpropagator) in zip(𝛁outputs.base, backpropagators).reversed() {
-//                 let (new𝛁cell, 𝛁input) = backpropagator(.init(output: 𝛁output, state: 𝛁state))
-//                 𝛁cell = new𝛁cell
-//                 𝛁state = 𝛁input.state
-//                 reversed𝛁inputs.append(𝛁input.input)
-//             }
-//             return (.init(cell: 𝛁cell), .init(Array(reversed𝛁inputs.reversed())))
-//         })
-//     }
-
-//     @differentiable(wrt: (self, inputs))
-//     public func call(_ inputs: [Cell.TimeStepInput]) -> [Cell.TimeStepOutput] {
-//         return self(inputs, initialState: cell.zeroState.withoutDerivative())
-//     }
-
-//     /* TODO: Uncomment once control flow and differentiation through force unwrapping is supported.
-//     @differentiable(wrt: (self, inputs))
-//     public func lastOutput(from inputs: [Cell.TimeStepInput],
-//                            initialState: Cell.State) -> Cell.TimeStepOutput {
-//         precondition(!inputs.isEmpty, "inputs cannot be empty")
-//         return self(inputs, initialState: initialState).last!
-//     }
-
-//     @differentiable(wrt: (self, inputs))
-//     public func lastOutput(from inputs: [Cell.TimeStepInput]) -> Cell.TimeStepOutput {
-//         precondition(!inputs.isEmpty, "inputs cannot be empty")
-//         return self(inputs, initialState: cell.zeroState).last!
-//     }
-//     */
-// }
-
-// extension RNN: Equatable where Cell: Equatable {}
-// extension RNN: AdditiveArithmetic where Cell: AdditiveArithmetic {}
-// extension RNN: VectorNumeric where Cell: VectorNumeric {}
-
-// public typealias SimpleRNN<Scalar: TensorFlowFloatingPoint> = RNN<SimpleRNNCell<Scalar>>
-// public typealias LSTM<Scalar: TensorFlowFloatingPoint> = RNN<LSTMCell<Scalar>>
+    public init(_ cell: @autoclosure () -> Cell) {
+        self.cell = cell()
+    }
+
+    @differentiable(wrt: (self, input), vjp: _vjpCall(_:initialState:))
+    public func call(_ input: [Cell.TimeStepInput],
+                     initialState: Cell.State) -> [Cell.TimeStepOutput] {
+        var currentHiddenState = initialState
+        var timeStepOutputs: [Cell.TimeStepOutput] = []
+        for timestep in input {
+            let output = cell(input: timestep, state: currentHiddenState)
+            currentHiddenState = output.state
+            timeStepOutputs.append(output.output)
+        }
+        return timeStepOutputs
+    }
+
+    @usableFromInline
+    internal func _vjpCall(
+        _ inputs: [Cell.TimeStepInput], initialState: Cell.State
+    ) -> ([Cell.TimeStepOutput],
+          (Array<Cell.TimeStepOutput>.CotangentVector)
+              -> (CotangentVector, Array<Cell.TimeStepInput>.CotangentVector)) {
+        let timeStepCount = inputs.count
+        var currentHiddenState = cell.zeroState
+        var timeStepOutputs: [Cell.TimeStepOutput] = []
+        timeStepOutputs.reserveCapacity(timeStepCount)
+        var backpropagators: [Cell.Backpropagator] = []
+        backpropagators.reserveCapacity(timeStepCount)
+        for timestep in inputs {
+            let (output, backpropagator) =
+                cell.appliedForBackpropagation(to: .init(input: timestep,
+                                                         state: currentHiddenState))
+            currentHiddenState = output.state
+            timeStepOutputs.append(output.output)
+            backpropagators.append(backpropagator)
+        }
+        return (timeStepOutputs, { 𝛁outputs in
+            precondition(𝛁outputs.base.count == timeStepCount,
+                         "The number of output gradients must equal the number of time steps")
+            var 𝛁cell = Cell.CotangentVector.zero
+            var 𝛁state = Cell.State.CotangentVector.zero
+            var reversed𝛁inputs: [Cell.TimeStepInput.CotangentVector] = []
+            reversed𝛁inputs.reserveCapacity(timeStepCount)
+            for (𝛁output, backpropagator) in zip(𝛁outputs.base, backpropagators).reversed() {
+                let (new𝛁cell, 𝛁input) = backpropagator(.init(output: 𝛁output, state: 𝛁state))
+                𝛁cell = new𝛁cell
+                𝛁state = 𝛁input.state
+                reversed𝛁inputs.append(𝛁input.input)
+            }
+            return (.init(cell: 𝛁cell), .init(Array(reversed𝛁inputs.reversed())))
+        })
+    }
+
+    @differentiable(wrt: (self, inputs))
+    public func call(_ inputs: [Cell.TimeStepInput]) -> [Cell.TimeStepOutput] {
+        return self(inputs, initialState: cell.zeroState.withoutDerivative())
+    }
+
+    /* TODO: Uncomment once control flow and differentiation through force unwrapping is supported.
+    @differentiable(wrt: (self, inputs))
+    public func lastOutput(from inputs: [Cell.TimeStepInput],
+                           initialState: Cell.State) -> Cell.TimeStepOutput {
+        precondition(!inputs.isEmpty, "inputs cannot be empty")
+        return self(inputs, initialState: initialState).last!
+    }
+
+    @differentiable(wrt: (self, inputs))
+    public func lastOutput(from inputs: [Cell.TimeStepInput]) -> Cell.TimeStepOutput {
+        precondition(!inputs.isEmpty, "inputs cannot be empty")
+        return self(inputs, initialState: cell.zeroState).last!
+    }
+    */
+}
+
+extension RNN: Equatable where Cell: Equatable {}
+extension RNN: AdditiveArithmetic where Cell: AdditiveArithmetic {}
+extension RNN: VectorNumeric where Cell: VectorNumeric {}
+
+public typealias SimpleRNN<Scalar: TensorFlowFloatingPoint> = RNN<SimpleRNNCell<Scalar>>
+public typealias LSTM<Scalar: TensorFlowFloatingPoint> = RNN<LSTMCell<Scalar>>
diff --git a/Sources/DeepLearning/Operators/Basic.swift b/Sources/DeepLearning/Operators/Basic.swift
index a719604e3..c461e25ee 100644
--- a/Sources/DeepLearning/Operators/Basic.swift
+++ b/Sources/DeepLearning/Operators/Basic.swift
@@ -378,11 +378,11 @@ public extension Tensor {
 
 public extension Tensor where Scalar: Numeric {
     @inlinable
-    func unbroadcast(toShape otherShape: Tensor<Int32>) -> Tensor<Scalar> {
-        let rankDiff = (rankTensor - otherShape.scalarCountTensor).rankLifted()
-        let ones = Raw.fill(dims: rankDiff, value: Tensor<Int32>(1))
+    func unbroadcast(toShape otherShape: Tensor<Int32>) -> Tensor {
+        let rankDiff: Tensor<Int32> = (rankTensor - otherShape.scalarCountTensor).rankLifted()
+        let ones: Tensor<Int32> = Raw.fill(dims: rankDiff, value: Tensor<Int32>(1))
         let paddedShape = Tensor<Int32>(concatenating: [ones, otherShape], alongAxis: 0)
-        let broadcastIndices = Tensor<Int32>(Raw.where_(paddedShape .!= shapeTensor).flattened())
+        let broadcastIndices = Tensor<Int32>(Raw.where_(paddedShape .!= shapeTensor))
         return sum(squeezingAxes: broadcastIndices).reshaped(toShape: otherShape)
     }
 
diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/DeepLearning/Operators/Math.swift
index c8590f7dc..8ef3a8dec 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/DeepLearning/Operators/Math.swift
@@ -14,10 +14,8 @@
 
 import TensorFlowCore
 
-// #if COMPILING_TENSORFLOW_MODULE
 infix operator .>: ComparisonPrecedence
 infix operator .==: ComparisonPrecedence
-// #endif
 
 // TODO:
 // - Consider explicit broadcasting for elementwise binary ops when
@@ -544,6 +542,20 @@ internal func _vjpExp<T: TensorFlowFloatingPoint>(
     return (value, { v in value * v })
 }
 
+/// Returns the values of the specified tensor rounded to the nearest integer, element-wise.
+@inlinable
+@differentiable(vjp: _vjpRound)
+public func round<T: TensorFlowFloatingPoint>(_ x: Tensor<T>) -> Tensor<T> {
+  return Raw.round(x)
+}
+
+@inlinable
+internal func _vjpRound<T: TensorFlowFloatingPoint>(
+  _ x: Tensor<T>
+) -> (Tensor<T>, (Tensor<T>) -> Tensor<T>) {
+  return (round(x), { v in Tensor<T>(zerosLike: v) })
+}
+
 /// Computes the ceiling of the specified tensor element-wise.
 @inlinable
 @differentiable(vjp: _vjpCeil(_:) where T: TensorFlowFloatingPoint)
@@ -1076,7 +1088,7 @@ public extension Tensor where Scalar: Numeric {
     @inlinable
     @differentiable(wrt: self, vjp: _vjpSum(squeezingAxes:) where Scalar: TensorFlowFloatingPoint)
     func sum(squeezingAxes axes: Tensor<Int32>) -> Tensor {
-        return Raw.sum(self, reductionIndices: Tensor<Int32>(axes), keepDims: false)
+        return Raw.sum(self, reductionIndices: axes, keepDims: false)
     }
 
     /// Returns the sum along the specified axes. The reduced dimensions are removed.
@@ -1304,8 +1316,8 @@ public extension Tensor where Scalar: Numeric {
         return variance(squeezingAxes: axes)
     }
 
-    @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
     @inlinable
+    @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
     func variance() -> Tensor {
         let mean = self.mean()
         let squaredDiff = (self - mean).squared()
@@ -1482,7 +1494,7 @@ public func matmul<Scalar: Numeric>(
 }
 
 @inlinable
-internal  func _vjpMatmul<Scalar: TensorFlowFloatingPoint>(
+internal func _vjpMatmul<Scalar: TensorFlowFloatingPoint>(
     _ lhs: Tensor<Scalar>,
     _ rhs: Tensor<Scalar>
 ) -> (Tensor<Scalar>, (Tensor<Scalar>) -> (Tensor<Scalar>, Tensor<Scalar>)) {
diff --git a/Sources/DeepLearning/Tensor.swift b/Sources/DeepLearning/Tensor.swift
index 20647a905..054ab3095 100644
--- a/Sources/DeepLearning/Tensor.swift
+++ b/Sources/DeepLearning/Tensor.swift
@@ -14,9 +14,7 @@
 
 import TensorFlowCore
 
-// #if COMPILING_TENSORFLOW_MODULE
 infix operator .==: ComparisonPrecedence
-// #endif
 
 //===------------------------------------------------------------------------------------------===//
 // Description and Visualization
diff --git a/Tests/DeepLearningTests/LayerTests.swift b/Tests/DeepLearningTests/LayerTests.swift
index a347c4d7e..2450020cd 100644
--- a/Tests/DeepLearningTests/LayerTests.swift
+++ b/Tests/DeepLearningTests/LayerTests.swift
@@ -103,21 +103,23 @@ final class LayerTests: XCTestCase {
         let (outputs, pullback) = rnn.valueWithPullback(at: inputs) { rnn, inputs in
             return rnn(inputs)
         }
-        XCTAssertEqual(outputs, [[[-0.0026294366, -0.0058668107,  0.04495003,  0.20311214]],
-                                 [[ 0.06788494,    0.050665878,   0.02415526,  0.09249911]],
-                                 [[ 0.06621192,    0.009049267,   0.065047316, 0.11534518]],
-                                 [[ 0.05612204,    0.00022032857, 0.05407162,  0.09784105]]])
-        let (𝛁rnn, 𝛁inputs) = pullback(.init(inputs))
-        XCTAssertEqual(𝛁rnn.cell.weight,
-                       [[          0.0,           0.0,           0.0,           0.0],
-                        [-0.0051278225,  0.0013102926,    0.00740262,   0.018119661],
-                        [ -0.010255645,  0.0026205853,    0.01480524,   0.036239322],
-                        [ -0.015383467,   0.003930878,    0.02220786,   0.054358985],
-                        [          0.0,           0.0,           0.0,           0.0],
-                        [          0.0,           0.0,           0.0,           0.0],
-                        [          0.0,           0.0,           0.0,           0.0],
-                        [          0.0,           0.0,           0.0,           0.0]])
-        XCTAssertEqual(𝛁rnn.cell.bias, [-0.051278222,  0.013102926,    0.0740262,   0.18119662])
+        XCTAssertEqual(Tensor<Int32>(Tensor<Float>(outputs).elementsApproximatelyEqual(
+            [[[-0.0026294366, -0.0058668107,  0.04495003,  0.20311214]],
+             [[ 0.06788494,    0.050665878,   0.02415526,  0.09249911]],
+             [[ 0.06621192,    0.009049267,   0.065047316, 0.11534518]],
+             [[ 0.05612204,    0.00022032857, 0.05407162,  0.09784105]]])).sum().scalarized(), 16)
+        let (𝛁rnn, _) = pullback(.init(inputs))
+        XCTAssertEqual(Tensor<Int32>(Tensor<Float>(𝛁rnn.cell.weight).elementsApproximatelyEqual(
+            [[          0.0,           0.0,           0.0,           0.0],
+             [-0.0051278225,  0.0013102926,    0.00740262,   0.018119661],
+             [ -0.010255645,  0.0026205853,    0.01480524,   0.036239322],
+             [ -0.015383467,   0.003930878,    0.02220786,   0.054358985],
+             [          0.0,           0.0,           0.0,           0.0],
+             [          0.0,           0.0,           0.0,           0.0],
+             [          0.0,           0.0,           0.0,           0.0],
+             [          0.0,           0.0,           0.0,           0.0]])).sum().scalarized(), 32)
+        XCTAssertEqual(Tensor<Int32>(Tensor<Float>(𝛁rnn.cell.bias).elementsApproximatelyEqual(
+            [-0.051278222,  0.013102926,    0.0740262,   0.18119662])).sum().scalarized(), 4)
     }
 
     static var allTests = [
diff --git a/Tests/DeepLearningTests/OperatorTests/MathTests.swift b/Tests/DeepLearningTests/OperatorTests/MathTests.swift
index 3f769be07..5ba18b569 100644
--- a/Tests/DeepLearningTests/OperatorTests/MathTests.swift
+++ b/Tests/DeepLearningTests/OperatorTests/MathTests.swift
@@ -88,7 +88,8 @@ final class MathOperatorTests: XCTestCase {
         let y = tanh(x)
         let array = y.array
         XCTAssertEqual([2], array.shape)
-        XCTAssertEqual([0.833655, 0.833655], array.scalars, accuracy: 0.0001)
+        XCTAssertEqual(0.833655, Double(array.scalars[0]))
+        XCTAssertEqual(0.833655, Double(array.scalars[1]))
     }
 
     func testStandardDeviation() {
@@ -101,10 +102,9 @@ final class MathOperatorTests: XCTestCase {
             accuracy: 0.001)
         let matrix = Tensor<Float>(rangeFrom: 0, to: 10, stride: 1).reshaped(to: [2, 5])
         XCTAssertEqual(2.87228132, matrix.standardDeviation().scalarized(), accuracy: 0.001)
-        XCTAssertEqual(
-            [1.4142, 1.4142],
-            matrix.standardDeviation(alongAxes: 1).array.scalars,
-            accuracy: 0.001)
+        let values = matrix.standardDeviation(alongAxes: 1).array.scalars
+        XCTAssertEqual(1.4142, Double(values[0]), accuracy: 0.0001)
+        XCTAssertEqual(1.4142, Double(values[1]), accuracy: 0.0001)
     }
 
     func test3Adds() {
@@ -129,9 +129,12 @@ final class MathOperatorTests: XCTestCase {
         XCTAssertEqual([2], array1.shape)
         XCTAssertEqual([2], array2.shape)
         XCTAssertEqual([2], array3.shape)
-        XCTAssertEqual([3.6, 3.6], array1.scalars, accuracy: 0.001)
-        XCTAssertEqual([12.96, 12.96], array2.scalars, accuracy: 0.001)
-        XCTAssertEqual([3.6, 3.6], array3.scalars, accuracy: 0.001)
+        XCTAssertEqual(3.6, Double(array1.scalars[0]), accuracy: 0.0001)
+        XCTAssertEqual(3.6, Double(array1.scalars[1]), accuracy: 0.0001)
+        XCTAssertEqual(12.96, Double(array2.scalars[0]), accuracy: 0.0001)
+        XCTAssertEqual(12.96, Double(array2.scalars[1]), accuracy: 0.0001)
+        XCTAssertEqual(3.6, Double(array3.scalars[0]), accuracy: 0.0001)
+        XCTAssertEqual(3.6, Double(array3.scalars[1]), accuracy: 0.0001)
     }
 
     func testXWPlusB() {
@@ -193,7 +196,7 @@ final class MathOperatorTests: XCTestCase {
         let input = Tensor<Float>([[1, 0.5]])
         let classifier = MLPClassifier()
         let prediction = classifier.prediction(for: input)
-        XCTAssertEqual([0.816997], prediction.scalars, accuracy: 0.001)
+        XCTAssertEqual(0.816997, Double(prediction.scalars[0]), accuracy: 0.0001)
     }
 
     static var allTests = [
diff --git a/Tests/DeepLearningTests/TensorTests.swift b/Tests/DeepLearningTests/TensorTests.swift
index ec7d1f6e3..03218f995 100644
--- a/Tests/DeepLearningTests/TensorTests.swift
+++ b/Tests/DeepLearningTests/TensorTests.swift
@@ -51,9 +51,15 @@ final class TensorTests: XCTestCase {
         XCTAssertEqual([3, 4, 5], tensor.shape)
     }
 
+    func testTensorShapeDescription() {
+        XCTAssertEqual("[2, 2]", Tensor<Int32>(ones: [2, 2]).shape.description)
+        XCTAssertEqual("[]", Tensor(1).shape.description)
+    }
+
     static var allTests = [
         ("testSimpleCond", testSimpleCond),
         ("testRankGetter", testRankGetter),
-        ("testShapeGetter", testShapeGetter)
+        ("testShapeGetter", testShapeGetter),
+        ("testTensorShapeDescription", testTensorShapeDescription)
     ]
 }

From a30c6ead04225557f90621bf6e68fc146ac902ee Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Fri, 26 Apr 2019 10:24:22 -0400
Subject: [PATCH 13/55] Addressed comments by @rxwei.

---
 Sources/DeepLearning/Initializers.swift       |   4 +-
 Sources/DeepLearning/Layer.swift              |   2 +-
 Sources/DeepLearning/Operators/Basic.swift    |  48 ++--
 .../DeepLearning/Operators/Comparison.swift   |  24 +-
 Sources/DeepLearning/Operators/Dataset.swift  | 270 +++++++++---------
 Sources/DeepLearning/Operators/Math.swift     |  16 +-
 Sources/DeepLearning/PythonConversion.swift   |   3 +-
 Sources/DeepLearning/Random.swift             |   2 +-
 Sources/DeepLearning/Tensor.swift             |   1 -
 .../DeepLearningTests/InitializerTests.swift  |  35 +--
 .../OperatorTests/BasicTests.swift            |   3 +-
 11 files changed, 190 insertions(+), 218 deletions(-)

diff --git a/Sources/DeepLearning/Initializers.swift b/Sources/DeepLearning/Initializers.swift
index 330e49453..073af0e12 100644
--- a/Sources/DeepLearning/Initializers.swift
+++ b/Sources/DeepLearning/Initializers.swift
@@ -127,7 +127,7 @@ public extension Tensor {
     /// Tensor(stacking: [x, y, z], alongAxis: 1) // is [[1, 2, 3], [4, 5, 6]]
     /// ```
     ///
-    /// This is the opposite of `Tensor.unstack(alongAxis:)`.
+    /// This is the opposite of `Tensor.unstacked(alongAxis:)`.
     ///
     /// - Parameters:
     ///   - tensors: Tensors to stack.
@@ -199,7 +199,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
     ) -> (Tensor, (Tensor) -> Array<Tensor>.DifferentiableView) {
         let result = Tensor(stacking: tensors, alongAxis: axis)
         return (result, { v in
-            Array<Tensor>.DifferentiableView(v.unstack(alongAxis: axis))
+            Array<Tensor>.DifferentiableView(v.unstacked(alongAxis: axis))
         })
     }
 
diff --git a/Sources/DeepLearning/Layer.swift b/Sources/DeepLearning/Layer.swift
index 4f3a5b9e6..add039fcb 100644
--- a/Sources/DeepLearning/Layer.swift
+++ b/Sources/DeepLearning/Layer.swift
@@ -557,7 +557,7 @@ public struct TransposedConv2D: Layer {
         self.activation = activation
         self.strides = strides
         self.padding = padding
-        self.paddingIndex = padding == .same ? 0: 1
+        self.paddingIndex = padding == .same ? 0 : 1
     }
 
     /// Returns the output obtained from applying the layer to the given input.
diff --git a/Sources/DeepLearning/Operators/Basic.swift b/Sources/DeepLearning/Operators/Basic.swift
index c461e25ee..34ffaa75f 100644
--- a/Sources/DeepLearning/Operators/Basic.swift
+++ b/Sources/DeepLearning/Operators/Basic.swift
@@ -19,7 +19,7 @@ import TensorFlowCore
 //===------------------------------------------------------------------------------------------===//
 
 public extension TensorFlowScalar {
-    /// Convert to a tensor with the specified rank, with all dimensions equal to 1.
+    /// Convert to a tensor with the specified rank, with all dimensions equal to `1`.
     @inlinable
     func makeTensor(rank: Int) -> Tensor<Self> {
         return Tensor(repeating: self, shape: TensorShape(rank))
@@ -49,38 +49,38 @@ public extension Tensor {
     /// 
     /// - Returns: Array containing the unstacked tensors.
     @inlinable
-    @differentiable(vjp: _vjpUnstack(alongAxis:) where Scalar: TensorFlowFloatingPoint)
-    func unstack(alongAxis axis: Int = 0) -> [Tensor] {
+    @differentiable(vjp: _vjpUnstacked(alongAxis:) where Scalar: TensorFlowFloatingPoint)
+    func unstacked(alongAxis axis: Int = 0) -> [Tensor] {
         return Raw.unpack(value: self, num: Int64(shape[axis]), axis: Int64(axis))
     }
 
     /// Splits a tensor into multiple tensors. The tensor is split along dimension `axis` into
-    /// `numSplits` smaller tensors. This requires that `numSplits` evenly divides `shape[axis]`.
+    /// `count` smaller tensors. This requires that `count` evenly divides `shape[axis]`.
     ///
     /// For example:
     /// ```
     /// // 'value' is a tensor with shape [5, 30]
     /// // Split 'value' into 3 tensors along dimension 1:
-    /// let parts = value.split(numSplits: 3, alongAxis: 1)
+    /// let parts = value.split(count: 3, alongAxis: 1)
     /// parts[0] // has shape [5, 10]
     /// parts[1] // has shape [5, 10]
     /// parts[2] // has shape [5, 10]
     /// ```
     ///
     /// - Parameters:
-    ///   - numSplits: Number of splits to create.
-    ///   - axis: Dimension along which to split this tensor. Negative values wrap around.
+    ///   - count: Number of splits to create.
+    ///   - axis: The dimension along which to split this tensor. Negative values wrap around.
     ///
-    /// - Precondition: `numSplits` must divide the size of dimension `axis` evenly.
+    /// - Precondition: `count` must divide the size of dimension `axis` evenly.
     /// - Precondition: `axis` must be in the range `[-rank, rank)`, where `rank` is the rank of the
     ///   provided tensors.
     ///
-    /// - Returns: Array containing the tensors parts.
+    /// - Returns: An array containing the tensors parts.
     @inlinable
-    @differentiable(vjp: _vjpSplit(numSplits:alongAxis:) where Scalar: TensorFlowFloatingPoint)
-    func split(numSplits: Int, alongAxis axis: Int = 0) -> [Tensor] {
+    @differentiable(vjp: _vjpSplit(count:alongAxis:) where Scalar: TensorFlowFloatingPoint)
+    func split(count: Int, alongAxis axis: Int = 0) -> [Tensor] {
         return Raw.split(
-            splitDim: Tensor<Int32>(Int32(axis)), value: self, numSplit: Int64(numSplits))
+            splitDim: Tensor<Int32>(Int32(axis)), value: self, numSplit: Int64(count))
     }
 
     /// Splits a tensor into multiple tensors. The tensor is split  into `sizes.shape[0]` pieces. 
@@ -177,7 +177,7 @@ public extension Tensor {
         return expandingShape(at: 0)
     }
 
-    /// Remove the specified dimensions of size 1 from the shape of a tensor. If no dimensions are
+    /// Removes the specified dimensions of size 1 from the shape of a tensor. If no dimensions are
     /// specified, then all dimensions of size 1 will be removed.
     @inlinable
     @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
@@ -185,7 +185,7 @@ public extension Tensor {
         return squeezingShape(at: axes)
     }
 
-    /// Remove the specified dimensions of size 1 from the shape of a tensor. If no dimensions are
+    /// Removes the specified dimensions of size 1 from the shape of a tensor. If no dimensions are
     /// specified, then all dimensions of size 1 will be removed.
     @inlinable
     @differentiable(wrt: self, vjp: _vjpSqueezingShape(at:) where Scalar: TensorFlowFloatingPoint)
@@ -196,19 +196,19 @@ public extension Tensor {
 
 internal extension Tensor where Scalar: TensorFlowFloatingPoint {
     @inlinable
-    func _vjpUnstack(
+    func _vjpUnstacked(
         alongAxis axis: Int = 0
     ) -> ([Tensor], (Array<Tensor>.CotangentVector) -> Tensor) {
-        let result = unstack(alongAxis: axis)
+        let result = unstacked(alongAxis: axis)
         return (result, { v in Tensor(stacking: v.base, alongAxis: axis) })
     }
 
     @inlinable
     func _vjpSplit(
-        numSplits: Int,
+        count: Int,
         alongAxis axis: Int = 0
     ) -> ([Tensor], (Array<Tensor>.CotangentVector) -> Tensor) {
-        let result = split(numSplits: numSplits, alongAxis: axis)
+        let result = split(count: count, alongAxis: axis)
         return (result, { v in Tensor(concatenating: v.base, alongAxis: axis) })
     }
 
@@ -354,25 +354,25 @@ infix operator .=
 
 public extension Tensor {
     @inlinable
-    func broadcast(toShape shape: Tensor<Int32>) -> Tensor {
+    func broadcasted(toShape shape: Tensor<Int32>) -> Tensor {
         return Raw.broadcastTo(self, shape: shape)
     }
 
     @inlinable
-    func broadcast(to shape: TensorShape) -> Tensor {
-        return broadcast(toShape: Tensor<Int32>(shape.dimensions.map(Int32.init)))
+    func broadcasted(to shape: TensorShape) -> Tensor {
+        return broadcasted(toShape: Tensor<Int32>(shape.dimensions.map(Int32.init)))
     }
 
     /// Broadcast to the same shape as the specified `Tensor`.
     /// - Precondition: The specified shape must be compatible for broadcasting.
     @inlinable
-    func broadcast<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor {
-        return broadcast(toShape: other.shapeTensor)
+    func broadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor {
+        return broadcasted(toShape: other.shapeTensor)
     }
 
     @inlinable
     static func .= (lhs: inout Tensor, rhs: Tensor) {
-        lhs = rhs.broadcast(like: lhs)
+        lhs = rhs.broadcasted(like: lhs)
     }
 }
 
diff --git a/Sources/DeepLearning/Operators/Comparison.swift b/Sources/DeepLearning/Operators/Comparison.swift
index 985686cf6..9fd7b4831 100644
--- a/Sources/DeepLearning/Operators/Comparison.swift
+++ b/Sources/DeepLearning/Operators/Comparison.swift
@@ -167,28 +167,28 @@ public extension Tensor where Scalar: Equatable {
     /// Computes `lhs != rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.==` supports broadcasting.
     @inlinable @inline(__always)
-    static func .==(lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
+    static func .== (lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.equal(lhs, rhs)
     }
 
     /// Computes `lhs != rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.!=` supports broadcasting.
     @inlinable @inline(__always)
-    static func .!=(lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
+    static func .!= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.notEqual(lhs, rhs)
     }
 
     /// Computes `lhs == rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.==` supports broadcasting.
     @inlinable @inline(__always)
-    static func .==(lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
+    static func .== (lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Tensor(lhs) .== rhs
     }
 
     /// Computes `lhs != rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.!=` supports broadcasting.
     @inlinable @inline(__always)
-    static func .!=(lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
+    static func .!= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Tensor(lhs) .!= rhs
     }
 
@@ -196,14 +196,14 @@ public extension Tensor where Scalar: Equatable {
     /// scalars.
     /// - Note: `.==` supports broadcasting.
     @inlinable @inline(__always)
-    static func .==(lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
+    static func .== (lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return lhs .== Tensor(rhs)
     }
 
     /// Computes `lhs != rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.!=` supports broadcasting.
     @inlinable @inline(__always)
-    static func .!=(lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
+    static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return lhs .!= Tensor(rhs)
     }
 }
@@ -223,10 +223,10 @@ public extension Tensor where Scalar: FloatingPoint & Equatable {
 }
 
 public extension StringTensor {
-  /// Computes `self == other` element-wise.
-  /// - Note: `elementsEqual` supports broadcasting.
-  @inlinable @inline(__always)
-  func elementsEqual(_ other: StringTensor) -> Tensor<Bool> {
-    return Raw.equal(self, other)
-  }
+    /// Computes `self == other` element-wise.
+    /// - Note: `elementsEqual` supports broadcasting.
+    @inlinable @inline(__always)
+    func elementsEqual(_ other: StringTensor) -> Tensor<Bool> {
+        return Raw.equal(self, other)
+    }
 }
diff --git a/Sources/DeepLearning/Operators/Dataset.swift b/Sources/DeepLearning/Operators/Dataset.swift
index 310094291..31d87c588 100644
--- a/Sources/DeepLearning/Operators/Dataset.swift
+++ b/Sources/DeepLearning/Operators/Dataset.swift
@@ -33,7 +33,7 @@ import TensorFlowCore
 // model TF's "global seed".
 @usableFromInline @inline(__always)
 func _tensorSeeds(_ seed: Tensor<Int64>) -> (Tensor<Int64>, Tensor<Int64>) {
-  return (Tensor(_defaultGraphSeed), seed)
+    return (Tensor(_defaultGraphSeed), seed)
 }
 
 //===----------------------------------------------------------------------===//
@@ -46,177 +46,177 @@ func _tensorSeeds(_ seed: Tensor<Int64>) -> (Tensor<Int64>, Tensor<Int64>) {
 /// element tensors.
 @_fixed_layout
 public struct Dataset<Element: TensorGroup> {
-  public let _handle: VariantHandle
+    public let _handle: VariantHandle
 
-  @inlinable @inline(__always)
-  public init(_handle: VariantHandle) {
-    self._handle = _handle
-  }
+    @inlinable @inline(__always)
+    public init(_handle: VariantHandle) {
+        self._handle = _handle
+    }
 }
 
 public extension Dataset {
-  @inlinable @inline(__always)
-  init(randomSeed: Int64) {
-    let (seed1, seed2) = _tensorSeeds(Tensor(randomSeed))
-    self.init(_handle: Raw.experimentalRandomDataset(
-      seed: seed1,
-      seed2: seed2,
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList))
-  }
+    @inlinable @inline(__always)
+    init(randomSeed: Int64) {
+        let (seed1, seed2) = _tensorSeeds(Tensor(randomSeed))
+        self.init(_handle: Raw.experimentalRandomDataset(
+            seed: seed1,
+            seed2: seed2,
+            outputTypes: Element._typeList,
+            outputShapes: Element._unknownShapeList))
+    }
 }
 
 public extension Dataset {
-  /// Creates a dataset from a batch of elements as a tensor.
-  @inlinable @inline(__always)
-  init(elements: Element) {
-    // A dataset creation op only runs on TF CPU.
-    self.init(_handle: Raw.tensorSliceDataset(
-      components: [elements],
-      outputShapes: Element._unknownShapeList))
-  }
+    /// Creates a dataset from a batch of elements as a tensor.
+    @inlinable @inline(__always)
+    init(elements: Element) {
+        // A dataset creation op only runs on TF CPU.
+        self.init(_handle: Raw.tensorSliceDataset(
+            components: [elements],
+            outputShapes: Element._unknownShapeList))
+    }
 }
 
 extension Dataset: Sequence {
-  public typealias Iterator = DatasetIterator<Element>
-
-  /// Returns an iterator over the elements of this dataset.
-  @inlinable @inline(__always)
-  public func makeIterator() -> DatasetIterator<Element> {
-    let resource = Raw.anonymousIterator(
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList)
-    Raw.makeIterator(dataset: _handle, iterator: resource)
-    return DatasetIterator(_handle: resource)
-  }
+    public typealias Iterator = DatasetIterator<Element>
+
+    /// Returns an iterator over the elements of this dataset.
+    @inlinable @inline(__always)
+    public func makeIterator() -> DatasetIterator<Element> {
+        let resource = Raw.anonymousIterator(
+            outputTypes: Element._typeList,
+            outputShapes: Element._unknownShapeList)
+        Raw.makeIterator(dataset: _handle, iterator: resource)
+        return DatasetIterator(_handle: resource)
+    }
 }
 
 public extension Dataset {
-  // Note that this Dataset API implementation uses an experimental tracing
-  // feature, which is not robust and does not have great diagnostics yet.
-  @inlinable @inline(__always)
-  func map<ResultElement: TensorGroup>(
-    _ transform: (Element) -> ResultElement
-  ) -> Dataset<ResultElement> {
-    return Dataset<ResultElement>(_handle: Raw.mapDataset(
-      inputDataset: _handle,
-      otherArguments: Tensor<Int32>(0),
-      f: transform,
-      outputTypes: ResultElement._typeList,
-      outputShapes: ResultElement._unknownShapeList,
-      useInterOpParallelism: true,
-      preserveCardinality: false))
-  }
-
-  @inlinable @inline(__always)
-  func filter(
-    _ isIncluded: (Element) -> Tensor<Bool>
-  ) -> Dataset {
-    return Dataset(_handle: Raw.filterDataset(
-      inputDataset: _handle,
-      otherArguments: Tensor<Int32>(0),
-      predicate: isIncluded,
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList))
-  }
+    // Note that this Dataset API implementation uses an experimental tracing
+    // feature, which is not robust and does not have great diagnostics yet.
+    @inlinable @inline(__always)
+    func map<ResultElement: TensorGroup>(
+        _ transform: (Element) -> ResultElement
+    ) -> Dataset<ResultElement> {
+        return Dataset<ResultElement>(_handle: Raw.mapDataset(
+            inputDataset: _handle,
+            otherArguments: Tensor<Int32>(0),
+            f: transform,
+            outputTypes: ResultElement._typeList,
+            outputShapes: ResultElement._unknownShapeList,
+            useInterOpParallelism: true,
+            preserveCardinality: false))
+    }
+
+    @inlinable @inline(__always)
+    func filter(
+        _ isIncluded: (Element) -> Tensor<Bool>
+    ) -> Dataset {
+        return Dataset(_handle: Raw.filterDataset(
+            inputDataset: _handle,
+            otherArguments: Tensor<Int32>(0),
+            predicate: isIncluded,
+            outputTypes: Element._typeList,
+            outputShapes: Element._unknownShapeList))
+    }
 }
 
 public extension Dataset {
-  @inlinable @inline(__always)
-  func prefetched(count: Int) -> Dataset {
-    return Dataset(_handle: Raw.prefetchDataset(
-      inputDataset: _handle,
-      bufferSize: Tensor(Int64(count)),
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList))
-  }
-
-  @inlinable @inline(__always)
-  func shuffled(
-    sampleCount: Int,
-    randomSeed: Int64,
-    reshuffleForEachIterator: Bool = true
-  ) -> Dataset {
-    let (seed1, seed2) = _tensorSeeds(Tensor(randomSeed))
-    return Dataset(_handle: Raw.shuffleDataset(
-      inputDataset: _handle,
-      bufferSize: Tensor(Int64(sampleCount)),
-      seed: seed1,
-      seed2: seed2,
-      reshuffleEachIteration: reshuffleForEachIterator,
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList))
-  }
-
-  @inlinable @inline(__always)
-  func batched(_ batchSize: Int) -> Dataset {
-    return Dataset(_handle: Raw.batchDataset(
-      inputDataset: _handle,
-      batchSize: Tensor(Int64(batchSize)),
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList))
-  }
-
-  @inlinable @inline(__always)
-  func repeated(count: Int? = nil) -> Dataset {
-    return Dataset(_handle: Raw.repeatDataset(
-      inputDataset: _handle,
-      count: Tensor(Int64(count ?? -1)),
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList))
-  }
+    @inlinable @inline(__always)
+    func prefetched(count: Int) -> Dataset {
+        return Dataset(_handle: Raw.prefetchDataset(
+            inputDataset: _handle,
+            bufferSize: Tensor(Int64(count)),
+            outputTypes: Element._typeList,
+            outputShapes: Element._unknownShapeList))
+    }
+
+    @inlinable @inline(__always)
+    func shuffled(
+        sampleCount: Int,
+        randomSeed: Int64,
+        reshuffleForEachIterator: Bool = true
+    ) -> Dataset {
+        let (seed1, seed2) = _tensorSeeds(Tensor(randomSeed))
+        return Dataset(_handle: Raw.shuffleDataset(
+            inputDataset: _handle,
+            bufferSize: Tensor(Int64(sampleCount)),
+            seed: seed1,
+            seed2: seed2,
+            reshuffleEachIteration: reshuffleForEachIterator,
+            outputTypes: Element._typeList,
+            outputShapes: Element._unknownShapeList))
+    }
+
+    @inlinable @inline(__always)
+    func batched(_ batchSize: Int) -> Dataset {
+        return Dataset(_handle: Raw.batchDataset(
+            inputDataset: _handle,
+            batchSize: Tensor(Int64(batchSize)),
+            outputTypes: Element._typeList,
+            outputShapes: Element._unknownShapeList))
+    }
+
+    @inlinable @inline(__always)
+    func repeated(count: Int? = nil) -> Dataset {
+        return Dataset(_handle: Raw.repeatDataset(
+            inputDataset: _handle,
+            count: Tensor(Int64(count ?? -1)),
+            outputTypes: Element._typeList,
+            outputShapes: Element._unknownShapeList))
+    }
 }
 
 /// The type that allows iteration over a dataset's elements.
 @_fixed_layout
 public struct DatasetIterator<Element: TensorGroup> {
-  @usableFromInline let _handle: ResourceHandle
+    @usableFromInline let _handle: ResourceHandle
 
-  @usableFromInline @inline(__always)
-  internal init(_handle: ResourceHandle) {
-    self._handle = _handle
-  }
+    @usableFromInline @inline(__always)
+    internal init(_handle: ResourceHandle) {
+        self._handle = _handle
+    }
 }
 
 extension DatasetIterator: IteratorProtocol {
-  /// Advances to the next element and returns it, or `nil` if no next element
-  /// exists.
-  @inlinable @inline(__always)
-  public mutating func next() -> Element? {
-    let optional = Raw.iteratorGetNextAsOptional(
-      iterator: _handle,
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList)
-    guard Raw.optionalHasValue(optional: optional).scalarized() else {
-      return nil
+    /// Advances to the next element and returns it, or `nil` if no next element
+    /// exists.
+    @inlinable @inline(__always)
+    public mutating func next() -> Element? {
+        let optional = Raw.iteratorGetNextAsOptional(
+            iterator: _handle,
+            outputTypes: Element._typeList,
+            outputShapes: Element._unknownShapeList)
+        guard Raw.optionalHasValue(optional: optional).scalarized() else {
+            return nil
+        }
+        return Raw.optionalGetValue(
+            optional: optional,
+            outputShapes: Element._unknownShapeList)
     }
-    return Raw.optionalGetValue(
-      optional: optional,
-      outputShapes: Element._unknownShapeList)
-  }
 }
 
 /// A 2-tuple-like struct that conforms to TensorGroup that represents a tuple 
 /// of 2 types conforming to TensorGroup.
 @_fixed_layout
 public struct Zip2TensorGroup<T: TensorGroup, U: TensorGroup>: TensorGroup {
-  public var first: T
-  public var second: U
+    public var first: T
+    public var second: U
 
-  public init(_ first: T, _ second: U) {
-    self.first = first
-    self.second = second
-  }
+    public init(_ first: T, _ second: U) {
+        self.first = first
+        self.second = second
+    }
 }
 
 // TODO(SR-9156): This does not work in graph mode.
 @inlinable @inline(__always)
 public func zip<T: TensorGroup, U: TensorGroup>(
-  _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
+    _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
 ) -> Dataset<Zip2TensorGroup<T, U>> {
-  let handle = Raw.zipDataset(
-    inputDatasets: [dataset1._handle, dataset2._handle],
-    outputTypes: Zip2TensorGroup<T, U>._typeList,
-    outputShapes: Zip2TensorGroup<T, U>._unknownShapeList)
-  return Dataset(_handle: handle)
+    let handle = Raw.zipDataset(
+        inputDatasets: [dataset1._handle, dataset2._handle],
+        outputTypes: Zip2TensorGroup<T, U>._typeList,
+        outputShapes: Zip2TensorGroup<T, U>._unknownShapeList)
+    return Dataset(_handle: handle)
 }
diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/DeepLearning/Operators/Math.swift
index 8ef3a8dec..0d3250d29 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/DeepLearning/Operators/Math.swift
@@ -567,7 +567,7 @@ public func ceil<T: FloatingPoint>(_ x: Tensor<T>) -> Tensor<T> {
 internal func _vjpCeil<T: TensorFlowFloatingPoint>(
     _ x: Tensor<T>
 ) -> (Tensor<T>, (Tensor<T>) -> Tensor<T>) {
-    return (ceil(x), { _ in Tensor(0).broadcast(like: x) })
+    return (ceil(x), { _ in Tensor(0).broadcasted(like: x) })
 }
 
 /// Computes the floor of the specified tensor element-wise.
@@ -581,7 +581,7 @@ public func floor<T: FloatingPoint>(_ x: Tensor<T>) -> Tensor<T> {
 internal func _vjpFloor<T: TensorFlowFloatingPoint>(
     _ x: Tensor<T>
 ) -> (Tensor<T>, (Tensor<T>) -> Tensor<T>) {
-    return (floor(x), { _ in Tensor(0).broadcast(like: x) })
+    return (floor(x), { _ in Tensor(0).broadcasted(like: x) })
 }
 
 /// Computes the sigmoid of the specified tensor element-wise.
@@ -1059,7 +1059,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
       let indicators = Tensor(yUnsqueezed .== self)
       let selectedCount = indicators.sum(alongAxes: axes)
 
-      return gradientUnsqueezed.broadcast(toShape: self.shapeTensor) * indicators / selectedCount
+      return gradientUnsqueezed.broadcasted(toShape: self.shapeTensor) * indicators / selectedCount
     })
   }
 
@@ -1072,7 +1072,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
       // them.
       let indicators = Tensor(result .== self)
       let selectedCount = indicators.sum(alongAxes: axes)
-      return v.broadcast(toShape: self.shapeTensor) * indicators / selectedCount
+      return v.broadcasted(toShape: self.shapeTensor) * indicators / selectedCount
     })
   }
 }
@@ -1362,7 +1362,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
     @inlinable
     func _vjpSum(alongAxes axes: Tensor<Int32>) -> (Tensor, (Tensor) -> Tensor) {
         let value = sum(alongAxes: axes)
-        return (value, { [shape = shapeTensor] in $0.broadcast(toShape: shape) })
+        return (value, { [shape = shapeTensor] in $0.broadcasted(toShape: shape) })
     }
 
     @inlinable
@@ -1370,7 +1370,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
         let value = sum(squeezingAxes: axes)
         return (value, { [shape = shapeTensor] v in
 	      let unsqueezed = v.expandingShape(at: axes.scalars.map { Int($0) })
-	      return unsqueezed.broadcast(toShape: shape)
+	      return unsqueezed.broadcasted(toShape: shape)
 	    })
     }
 
@@ -1378,7 +1378,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
     func _vjpMean(alongAxes axes: Tensor<Int32>) -> (Tensor, (Tensor) -> Tensor) {
         let value = mean(alongAxes: axes)
         let count = Raw.gather(params: shapeTensor, indices: axes).product()
-        return (value, { [shape = shapeTensor] in $0.broadcast(toShape: shape) / Tensor(count) })
+        return (value, { [shape = shapeTensor] in $0.broadcasted(toShape: shape) / Tensor(count) })
     }
 
     @inlinable
@@ -1387,7 +1387,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
         let count = Raw.gather(params: shapeTensor, indices: axes).product()
         return (value, { [shape = shapeTensor] v in
 	      let unsqueezed = v.expandingShape(at: axes.scalars.map { Int($0) })
-	      return unsqueezed.broadcast(toShape: shape) / Tensor(count)
+	      return unsqueezed.broadcasted(toShape: shape) / Tensor(count)
 	    })
     }
 }
diff --git a/Sources/DeepLearning/PythonConversion.swift b/Sources/DeepLearning/PythonConversion.swift
index 2c1a6a377..475fd3b7b 100644
--- a/Sources/DeepLearning/PythonConversion.swift
+++ b/Sources/DeepLearning/PythonConversion.swift
@@ -89,8 +89,7 @@ extension ShapedArray: ConvertibleFromNumpyArray
     }
 }
 
-extension Tensor: ConvertibleFromNumpyArray
-    where Scalar: NumpyScalarCompatible {
+extension Tensor: ConvertibleFromNumpyArray where Scalar: NumpyScalarCompatible {
     /// Creates a tensor with the same shape and scalars as the specified
     /// `numpy.ndarray` instance.
     ///
diff --git a/Sources/DeepLearning/Random.swift b/Sources/DeepLearning/Random.swift
index ade75a826..ea0783f1d 100644
--- a/Sources/DeepLearning/Random.swift
+++ b/Sources/DeepLearning/Random.swift
@@ -536,7 +536,7 @@ public struct BetaDistribution: RandomDistribution {
         } while r + alpha * (log(alpha) - log(b + w)) < t
 
         w = min(w, Float.greatestFiniteMagnitude)
-        return a == alpha0 ? w / (b + w): b / (b + w)
+        return a == alpha0 ? w / (b + w) : b / (b + w)
     }
 
     /// Returns one sample from a Beta(alpha, beta) distribution using Cheng's BC
diff --git a/Sources/DeepLearning/Tensor.swift b/Sources/DeepLearning/Tensor.swift
index 054ab3095..c94354ff1 100644
--- a/Sources/DeepLearning/Tensor.swift
+++ b/Sources/DeepLearning/Tensor.swift
@@ -44,7 +44,6 @@ public extension Tensor {
     ///     via ellipses (`...`).
     ///   - summarizing: If true, summarize description if element count exceeds twice
     ///     `edgeElementCount`.
-    @_semantics("autodiff.nonvarying")
     func description(
         lineWidth: Int = 80,
         edgeElementCount: Int = 3,
diff --git a/Tests/DeepLearningTests/InitializerTests.swift b/Tests/DeepLearningTests/InitializerTests.swift
index 3407e5816..ced975f98 100644
--- a/Tests/DeepLearningTests/InitializerTests.swift
+++ b/Tests/DeepLearningTests/InitializerTests.swift
@@ -20,9 +20,7 @@ final class InitializerTests: XCTestCase {
         let scalar = Tensor<Float>(1)
         let matrix: Tensor<Float> = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]
         let broadcastScalar = Tensor<Float>(broadcasting: 10, rank: 3)
-        let some4d = Tensor<Float>(
-            shape: [2, 1, 2, 1],
-            scalars: AnyRandomAccessCollection([2, 3, 4, 5]))
+        let some4d = Tensor<Float>(shape: [2, 1, 2, 1], scalars: [2, 3, 4, 5])
         XCTAssertEqual(ShapedArray(shape: [2, 1, 2, 1], scalars: [2, 3, 4, 5]), some4d.array)
         XCTAssertEqual(ShapedArray(shape: [], scalars: [1]), scalar.array)
         XCTAssertEqual(ShapedArray(shape: [2, 3], scalars: [1, 2, 3, 4, 5, 6]), matrix.array)
@@ -53,23 +51,7 @@ final class InitializerTests: XCTestCase {
         XCTAssertEqual(array3D, tensor3D.array)
     }
 
-    func testNonTPUDataTypeCast() {
-        // TPU does not support Int8 or 16 casting.
-        guard !_RuntimeConfig.executionMode.isTPU else { return }
-
-        let x = Tensor<Int32>(ones: [5, 5])
-        let ints = Tensor<Int64>(x)
-        let floats = Tensor<Float>(x)
-        let i8s = Tensor<Int8>(floats)
-        XCTAssertEqual(ShapedArray(repeating: 1, shape: [5, 5]), ints.array)
-        XCTAssertEqual(ShapedArray(repeating: 1, shape: [5, 5]), floats.array)
-        XCTAssertEqual(ShapedArray(repeating: 1, shape: [5, 5]), i8s.array)
-    }
-
-    func testTPUDataTypeCast() {
-        // Non-TPU mode (e.g. eager) does not support Uint32 casting.
-        guard _RuntimeConfig.executionMode.isTPU else { return }
-
+    func testDataTypeCast() {
         let x = Tensor<Int32>(ones: [5, 5])
         let ints = Tensor<Int64>(x)
         let floats = Tensor<Float>(x)
@@ -79,13 +61,7 @@ final class InitializerTests: XCTestCase {
         XCTAssertEqual(ShapedArray(repeating: 1, shape: [5, 5]), u32s.array)
     }
 
-    func testNonTPUBoolToNumericCast() {
-        // TPU does not support Int8 or 16 casting.
-        //
-        // When changing to UInt32, got another TPU/XLA compilation error when
-        // converting from bools to Uint32 (different from missing kernel error).
-        if _RuntimeConfig.executionMode.isTPU { return }
-
+    func testBoolToNumericCast() {
         let bools = Tensor<Bool>(shape: [2, 2], scalars: [true, false, true, false])
         let ints = Tensor<Int64>(bools)
         let floats = Tensor<Float>(bools)
@@ -101,8 +77,7 @@ final class InitializerTests: XCTestCase {
         ("testNumericInitializers", testNumericInitializers),
         ("testScalarToTensorConversion", testScalarToTensorConversion),
         ("testArrayConversion", testArrayConversion),
-        ("testNonTPUDataTypeCast", testNonTPUDataTypeCast),
-        ("testTPUDataTypeCast", testTPUDataTypeCast),
-        ("testNonTPUBoolToNumericCast", testNonTPUBoolToNumericCast)
+        ("testDataTypeCast", testDataTypeCast),
+        ("testBoolToNumericCast", testBoolToNumericCast)
     ]
 }
diff --git a/Tests/DeepLearningTests/OperatorTests/BasicTests.swift b/Tests/DeepLearningTests/OperatorTests/BasicTests.swift
index ae25efbc5..b3afb3ba1 100644
--- a/Tests/DeepLearningTests/OperatorTests/BasicTests.swift
+++ b/Tests/DeepLearningTests/OperatorTests/BasicTests.swift
@@ -424,7 +424,6 @@ final class BasicOperatorTests: XCTestCase {
     }
 
     func testSliceUpdate() {
-        guard !_RuntimeConfig.executionMode.isTPU else { return }
         var t1 = Tensor<Float>([[1, 2, 3], [4, 5, 6]])
         t1[0] = Tensor(zeros: [3])
         XCTAssertEqual(ShapedArray(shape:[2, 3], scalars: [0, 0, 0, 4, 5, 6]), t1.array)
@@ -444,7 +443,7 @@ final class BasicOperatorTests: XCTestCase {
         // 1 -> 2 x 3 x 4
         let one = Tensor<Float>(1)
         var target = Tensor<Float>(repeating: 0.0, shape: [2, 3, 4])
-        let broadcasted = one.broadcast(like: target)
+        let broadcasted = one.broadcasted(like: target)
         XCTAssertEqual(Tensor(repeating: 1, shape: [2, 3, 4]), broadcasted)
         target .= Tensor(repeating: 1, shape: [1, 3, 1])
         XCTAssertEqual(Tensor(repeating: 1, shape: [2, 3, 4]), target)

From 1ca25e97356b4498f0f725ef41663b3d0417b74d Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sat, 27 Apr 2019 22:48:04 -0400
Subject: [PATCH 14/55] Addressed Richard's feedback.

---
 Sources/DeepLearning/Context.swift            |    2 -
 .../{ => Core}/DifferentialOperators.swift    |    0
 .../{ => Core}/PythonConversion.swift         |    2 -
 Sources/DeepLearning/Core/ShapedArray.swift   | 1143 +++++++++++++++++
 Sources/DeepLearning/Core/StringTensor.swift  |   70 +
 Sources/DeepLearning/Core/Tensor.swift        |  645 ++++++++++
 Sources/DeepLearning/Core/TensorGroup.swift   |  102 ++
 Sources/DeepLearning/Core/TensorHandle.swift  |   26 +
 Sources/DeepLearning/Core/Utilities.swift     |   70 +
 Sources/DeepLearning/Helpers.swift            |    2 -
 Sources/DeepLearning/Layer.swift              |  532 ++++----
 Sources/DeepLearning/Operators/Basic.swift    |   20 +-
 Sources/DeepLearning/Operators/Dataset.swift  |   32 +-
 Sources/DeepLearning/Operators/Math.swift     |   65 +-
 Sources/DeepLearning/Optimizer.swift          |    2 -
 Sources/DeepLearning/Random.swift             |    2 +
 Sources/DeepLearning/Tensor.swift             |  105 --
 .../OperatorTests/BasicTests.swift            |   12 +-
 18 files changed, 2405 insertions(+), 427 deletions(-)
 rename Sources/DeepLearning/{ => Core}/DifferentialOperators.swift (100%)
 rename Sources/DeepLearning/{ => Core}/PythonConversion.swift (99%)
 create mode 100644 Sources/DeepLearning/Core/ShapedArray.swift
 create mode 100644 Sources/DeepLearning/Core/StringTensor.swift
 create mode 100644 Sources/DeepLearning/Core/Tensor.swift
 create mode 100644 Sources/DeepLearning/Core/TensorGroup.swift
 create mode 100644 Sources/DeepLearning/Core/TensorHandle.swift
 create mode 100644 Sources/DeepLearning/Core/Utilities.swift
 delete mode 100644 Sources/DeepLearning/Tensor.swift

diff --git a/Sources/DeepLearning/Context.swift b/Sources/DeepLearning/Context.swift
index c607e902e..6a03d405b 100644
--- a/Sources/DeepLearning/Context.swift
+++ b/Sources/DeepLearning/Context.swift
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
 import Darwin
 #else
diff --git a/Sources/DeepLearning/DifferentialOperators.swift b/Sources/DeepLearning/Core/DifferentialOperators.swift
similarity index 100%
rename from Sources/DeepLearning/DifferentialOperators.swift
rename to Sources/DeepLearning/Core/DifferentialOperators.swift
diff --git a/Sources/DeepLearning/PythonConversion.swift b/Sources/DeepLearning/Core/PythonConversion.swift
similarity index 99%
rename from Sources/DeepLearning/PythonConversion.swift
rename to Sources/DeepLearning/Core/PythonConversion.swift
index 475fd3b7b..017658026 100644
--- a/Sources/DeepLearning/PythonConversion.swift
+++ b/Sources/DeepLearning/Core/PythonConversion.swift
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 #if canImport(Python)
 import Python
 
diff --git a/Sources/DeepLearning/Core/ShapedArray.swift b/Sources/DeepLearning/Core/ShapedArray.swift
new file mode 100644
index 000000000..dff4dd3d1
--- /dev/null
+++ b/Sources/DeepLearning/Core/ShapedArray.swift
@@ -0,0 +1,1143 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+import Swift
+import CTensorFlow
+import TensorFlowCore
+
+//===------------------------------------------------------------------------------------------===//
+// TensorBuffer
+//===------------------------------------------------------------------------------------------===//
+
+/// `TensorBuffer` is the internal storage of `ShapedArray`. This buffer has two modes of storage: 
+/// `native` and `tensorFlow`. In `native` mode, the buffer object stores a pointer to contiguous 
+/// scalars; in `tensorFlow` mode, the buffer object stores a `TF_Tensor*` and bridges to 
+/// TensorFlow. In either mode, the buffer object owns the memory and will deallocate it on 
+/// `deinit`.
+@_fixed_layout @usableFromInline
+internal final class TensorBuffer<Scalar> {
+    typealias Shape = [Int]
+
+    /// A reference type wrapping a Swift Array.
+    /// - Note: An array is used as the native storage for `TensorBuffer`. To make in-place mutation 
+    ///   possible when the array is stored in an enumeration value, the array must be wrapped in a 
+    ///   reference type.
+    @_fixed_layout @usableFromInline
+    final class BoxedArray {
+        var array: [Scalar]
+
+        init(_ array: __owned [Scalar]) {
+            self.array = array
+        }
+    }
+
+    enum Allocation {
+        case native(BoxedArray)
+        case tensorFlow(CTensor)
+    }
+
+    let allocation: Allocation
+    let count: Int
+
+    deinit {
+        debugLog("De-initializing tensor buffer.")
+        switch allocation {
+        case .native:
+            debugLog("Deallocating underlying buffer.")
+        case let .tensorFlow(cTensor):
+            debugLog("Deleting underlying tensor.")
+            TF_DeleteTensor(cTensor)
+        }
+        debugLog("Returning from deinit of TensorBuffer.")
+    }
+
+    init(allocation: Allocation, count: Int) {
+        self.allocation = allocation
+        self.count = count
+    }
+}
+
+// TF Tensor-specific initializer.
+extension TensorBuffer where Scalar: _TensorFlowDataTypeCompatible {
+    /// Creates a local tensor buffer from a C `TF_Tensor*` value and takes ownership of the value.
+    convenience init(owning cTensor: CTensor, count: Int) {
+        debugLog("Initializing TensorBuffer with a cTensor of \(count) elements.")
+        let actualCount = (0..<TF_NumDims(cTensor)).reduce(1) { accumulator, next in
+            accumulator * Int(TF_Dim(cTensor, next))
+        }
+        assert(actualCount == count)
+        self.init(allocation: .tensorFlow(cTensor), count: count)
+    }
+}
+
+// Factory methods.
+extension TensorBuffer {
+    static func create(
+        count: Int,
+        withInitializer body: (UnsafeMutableBufferPointer<Scalar>) -> Void
+    ) -> TensorBuffer<Scalar> {
+        /// Since `Scalar` may be any generic type, it is not possible to construct
+        /// an instance of `Scalar` directly for use with the
+        /// `Array(repeating:count:)` initializer. The workaround here is to
+        /// allocate a dummy `Scalar` pointer of size 1 and to use the pointee value
+        /// as the `repeatedValue` of the initializer.
+        let dummyPointer = UnsafeMutablePointer<Scalar>.allocate(capacity: 1)
+        var array = Array(repeating: dummyPointer.move(), count: count)
+        array.withUnsafeMutableBufferPointer { body($0) }
+        dummyPointer.deallocate()
+        return TensorBuffer(allocation: .native(BoxedArray(array)), count: count)
+    }
+}
+
+// Unsafe address accessor.
+extension TensorBuffer {
+    func withUnsafeBufferPointer<R>(
+        _ body: (UnsafeBufferPointer<Scalar>) throws -> R
+    ) rethrows -> R {
+        switch allocation {
+        case let .native(box):
+            return try box.array.withUnsafeBufferPointer { pointer in try body(pointer) }
+        case let .tensorFlow(cTensor):
+            let startAddress = TF_TensorData(cTensor).assumingMemoryBound(to: Scalar.self)
+            let bufferPointer = UnsafeBufferPointer(start: startAddress, count: count)
+            return try body(bufferPointer)
+        }
+    }
+
+    func withUnsafeMutableBufferPointer<R>(
+        _ body: (inout UnsafeMutableBufferPointer<Scalar>) throws -> R
+    ) rethrows -> R {
+        switch allocation {
+        case let .native(box):
+            return try box.array.withUnsafeMutableBufferPointer { pointer in try body(&pointer) }
+        case let .tensorFlow(cTensor):
+            let startAddress = TF_TensorData(cTensor).assumingMemoryBound(to: Scalar.self)
+            var bufferPointer = UnsafeMutableBufferPointer(start: startAddress, count: count)
+            return try body(&bufferPointer)
+        }
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// ShapedArrayProtocol: The protocol unifying ShapedArray and ShapedArraySlice.
+//===------------------------------------------------------------------------------------------===//
+
+public protocol _ShapedArrayProtocol: RandomAccessCollection, MutableCollection {
+    associatedtype Scalar
+
+    /// The number of dimensions of the array.
+    var rank: Int { get }
+    /// The shape of the array.
+    var shape: [Int] { get }
+    /// The total number of scalars in the array.
+    var scalarCount: Int { get }
+
+    /// Creates an array with the specified shape and contiguous scalars in row-major order.
+    /// - Precondition: The number of scalars must equal the product of the dimensions of the shape.
+    init(shape: [Int], scalars: [Scalar])
+
+    /// Creates an array with the specified shape and sequence of scalars in row-major order.
+    /// - Precondition: The number of scalars must equal the product of the dimensions of the shape.
+    init<S: Sequence>(shape: [Int], scalars: S) where S.Element == Scalar
+
+    /// Calls a closure with a pointer to the array’s contiguous storage.
+    /// - Parameter body: A closure with an `UnsafeBufferPointer` parameter that points to the 
+    ///   contiguous storage for the array. If no such storage exists, it is created. If body has a 
+    ///   return value, that value is also used as the return value for the 
+    ///   `withUnsafeBufferPointer(_:)` method. The pointer argument is valid only for the duration 
+    ///   of the method's execution.
+    func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<Scalar>) throws -> R) rethrows -> R
+
+    /// Calls the given closure with a pointer to the array’s mutable contiguous storage.
+    /// - Parameter body: A closure with an `UnsafeMutableBufferPointer` parameter that points to 
+    ///   the contiguous storage for the array. If no such storage exists, it is created. If body 
+    ///   has a return value, that value is also used as the return value for the
+    ///   `withUnsafeMutableBufferPointer(_:)` method. The pointer argument is valid only for the 
+    ///   duration of the method's execution.
+    mutating func withUnsafeMutableBufferPointer<R>(
+        _ body: (inout UnsafeMutableBufferPointer<Scalar>) throws -> R
+    ) rethrows -> R
+}
+
+public extension _ShapedArrayProtocol {
+    /// The scalars of the array in row-major order.
+    var scalars: [Scalar] {
+        get {
+            return withUnsafeBufferPointer(Array.init)
+        }
+        set {
+            precondition(newValue.count == scalarCount, "Scalar count mismatch.")
+            withUnsafeMutableBufferPointer { pointer in
+                pointer.baseAddress!.initialize(from: newValue, count: newValue.count)
+            }
+        }
+    }
+
+    /// Returns `true` if the array has rank 0.
+    var isScalar: Bool {
+        return rank == 0
+    }
+
+    /// Returns the single scalar element if the array has rank 0 and `nil` otherwise.
+    var scalar: Scalar? {
+        get {
+            guard rank == 0 else { return nil }
+            return scalars.first
+        }
+        set {
+            precondition(isScalar, "Array does not have shape [].")
+            guard let newValue = newValue else {
+                preconditionFailure("New scalar value cannot be nil.")
+            }
+            scalars[0] = newValue
+        }
+    }
+}
+
+public extension _ShapedArrayProtocol where Scalar: Equatable {
+    static func == <Other>(lhs: Self, rhs: Other) -> Bool 
+        where Other: _ShapedArrayProtocol, Scalar == Other.Scalar {
+        return lhs.shape == rhs.shape && lhs.scalars.elementsEqual(rhs.scalars)
+    }
+}
+
+public extension _ShapedArrayProtocol {
+    /// Returns the number of element arrays in an array (equivalent to the first dimension).
+    /// - Note: `count` is distinct from `scalarCount`, which represents the 
+    ///   total number of scalars.
+    var count: Int {
+        return shape.first ?? 0
+    }
+}
+
+internal extension _ShapedArrayProtocol {
+    /// Returns the scalar count for an element of the array.
+    var scalarCountPerElement: Int {
+        return shape.isEmpty ? 0 : shape.dropFirst().reduce(1, *)
+    }
+
+    /// Returns the scalar index corresponding to an index in the leading dimension of the array.
+    func scalarIndex(fromIndex index: Int) -> Int {
+        return scalarCountPerElement * index
+    }
+
+    /// Returns the range of scalars corresponding to a range in the leading dimension of the array.
+    func scalarSubrange(from arraySubrange: Range<Int>) -> Range<Int> {
+        return scalarIndex(fromIndex: arraySubrange.lowerBound) 
+            ..< scalarIndex(fromIndex: arraySubrange.upperBound)
+    }
+}
+
+fileprivate extension String {
+    /// Returns a string of the specified length, padded with whitespace to the left.
+    func leftPadded(toLength length: Int) -> String {
+        return repeatElement(" ", count: max(0, length - count)) + self
+    }
+}
+
+// Common public protocol implementations.
+
+fileprivate extension _ShapedArrayProtocol
+    where Element: _ShapedArrayProtocol, Element == Element.Element {
+    /// Returns the whitespace separator between elements, given the current indent level.
+    func separator(indentLevel: Int) -> String {
+        if rank == 1 {
+            return ", "
+        }
+        return String(repeating: "\n", count: rank - 1) + 
+            String(repeating: " ", count: indentLevel + 1)
+    }
+
+    /// A textual representation of the 1-D shaped array, starting at the given indent level. 
+    /// Returns a summarized description if `summarizing` is true and the element count exceeds
+    /// twice the `edgeElementCount`.
+    ///
+    /// - Parameters:
+    ///   - indentLevel: The indentation level.
+    ///   - edgeElementCount: The maximum number of elements to print before and after summarization 
+    ///     via ellipses (`...`).
+    ///   - maxScalarLength: The length of the longest scalar description in the entire original
+    ///     array-to-print.
+    ///   - maxScalarCountPerLine: The maximum number of scalars to print per line, used when
+    ///     printing 1-D vectors.
+    ///   - summarizing: If true, summarize description if element count exceeds twice
+    ///     `edgeElementCount`.
+    func vectorDescription(
+        indentLevel: Int,
+        edgeElementCount: Int,
+        maxScalarLength: Int,
+        maxScalarCountPerLine: Int,
+        summarizing: Bool
+    ) -> String {
+        // Get scalar descriptions.
+        func scalarDescription(_ element: Element) -> String {
+            let description = String(describing: element)
+            return description.leftPadded(toLength: maxScalarLength)
+        }
+
+        var scalarDescriptions: [String] = []
+        if summarizing && count > 2 * edgeElementCount {
+            scalarDescriptions += prefix(edgeElementCount).map(scalarDescription)
+            scalarDescriptions += ["..."]
+            scalarDescriptions += suffix(edgeElementCount).map(scalarDescription)
+        } else {
+            scalarDescriptions += map(scalarDescription)
+        }
+
+        // Combine scalar descriptions into lines, based on the scalar count per line.
+        let lines = stride(
+            from: scalarDescriptions.startIndex,
+            to: scalarDescriptions.endIndex,
+            by: maxScalarCountPerLine
+        ).map { i -> ArraySlice<String> in
+            let upperBound = Swift.min(
+                i.advanced(by: maxScalarCountPerLine),
+                scalarDescriptions.count)
+            return scalarDescriptions[i..<upperBound]
+        }
+
+        // Return lines joined with separators.
+        let lineSeparator = ",\n" + String(repeating: " ", count: indentLevel + 1)
+        return lines.enumerated().reduce(into: "[") { result, entry in
+            let (i, line) = entry
+            result += line.joined(separator: ", ")
+            result += i != lines.count - 1 ? lineSeparator : ""
+        } + "]"
+    }
+
+    /// A textual representation of the shaped array, starting at the given indent level. Returns a 
+    /// summarized description if `summarizing` is true and the element count exceeds twice the
+    /// `edgeElementCount`.
+    ///
+    /// - Parameters:
+    ///   - indentLevel: The indentation level.
+    ///   - edgeElementCount: The maximum number of elements to print before and after summarization
+    ///     via ellipses (`...`).
+    ///   - maxScalarLength: The length of the longest scalar description in the entire original
+    ///     array-to-print.
+    ///   - maxScalarCountPerLine: The maximum number of scalars to print per line, used when 
+    ///     printing 1-D vectors.
+    ///   - summarizing: If true, summarizing description if element count exceeds twice
+    ///     `edgeElementCount`.
+    func description(
+        indentLevel: Int,
+        edgeElementCount: Int,
+        maxScalarLength: Int,
+        maxScalarCountPerLine: Int,
+        summarizing: Bool
+    ) -> String {
+        // Handle scalars.
+        if let scalar = scalar {
+            return String(describing: scalar)
+        }
+
+        // Handle vectors, which have special line-width-sensitive logic.
+        if rank == 1 {
+            return vectorDescription(
+                indentLevel: indentLevel,
+                edgeElementCount: edgeElementCount,
+                maxScalarLength: maxScalarLength,
+                maxScalarCountPerLine: maxScalarCountPerLine,
+                summarizing: summarizing)
+        }
+
+        // Handle higher-rank tensors.
+        func elementDescription(_ element: Element) -> String {
+            return element.description(
+                indentLevel: indentLevel + 1,
+                edgeElementCount: edgeElementCount,
+                maxScalarLength: maxScalarLength,
+                maxScalarCountPerLine: maxScalarCountPerLine,
+                summarizing: summarizing)
+        }
+
+        var elementDescriptions: [String] = []
+        if summarizing && count > 2 * edgeElementCount {
+            elementDescriptions += prefix(edgeElementCount).map(elementDescription)
+            elementDescriptions += ["..."]
+            elementDescriptions += suffix(edgeElementCount).map(elementDescription)
+        } else {
+            elementDescriptions += map(elementDescription)
+        }
+
+        // Return lines joined with separators.
+        let lineSeparator = "," +
+            String(repeating: "\n", count: rank - 1) +
+            String(repeating: " ", count: indentLevel + 1)
+        return elementDescriptions.enumerated().reduce(into: "[") { result, entry in
+            let (i, elementDescription) = entry
+            result += elementDescription
+            result += i != elementDescriptions.count - 1 ? lineSeparator : ""
+        } + "]"
+    }
+}
+
+public extension _ShapedArrayProtocol
+    where Element: _ShapedArrayProtocol, Element == Element.Element {
+    /// A textual representation of the shaped array. Returns a summarized description if
+    /// `summarizing` is true and the element count exceeds twice the `edgeElementCount`.
+    ///
+    /// - Parameters:
+    ///   - lineWidth: The max line width for printing. Used to determine number of scalars to print
+    ///     per line.
+    ///   - edgeElementCount: The maximum number of elements to print before and after summarization 
+    ///     via ellipses (`...`).
+    ///   - summarizing: If true, summarizing description if element count exceeds twice
+    ///     `edgeElementCount`.
+    func description(
+        lineWidth: Int = 80,
+        edgeElementCount: Int = 3,
+        summarizing: Bool = false
+    ) -> String {
+        // Compute the number of scalars to print per line.
+        let maxScalarLength = scalars.lazy.map { String(describing: $0).count }.max() ?? 3
+        let maxScalarCountPerLine = Swift.max(1, lineWidth / maxScalarLength)
+        return description(
+            indentLevel: 0,
+            edgeElementCount: edgeElementCount,
+            maxScalarLength: maxScalarLength,
+            maxScalarCountPerLine: maxScalarCountPerLine,
+            summarizing: summarizing)
+    }
+
+    /// A full, non-pretty-printed textual representation of the shaped array, showing all scalars.
+    var fullDescription: String {
+        if let scalar = scalar {
+            return String(describing: scalar)
+        }
+        return "[\( map({"\($0.fullDescription)"}).joined(separator: ", ") )]"
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// ShapedArray
+//===------------------------------------------------------------------------------------------===//
+
+/// `ShapedArray` is a multi-dimensional array. It has a shape, which has type `[Int]` and defines
+/// the array dimensions, and uses a `TensorBuffer` internally as storage.
+@_fixed_layout
+public struct ShapedArray<Scalar>: _ShapedArrayProtocol {
+    /// Contiguous memory storing scalars.
+    internal var buffer: TensorBuffer<Scalar>
+
+    /// The dimensions of the array.
+    public private(set) var shape: [Int]
+
+    /// Creates a `ShapedArray` from a `TensorBuffer` and a shape.
+    internal init(buffer: __owned TensorBuffer<Scalar>, shape: __owned [Int]) {
+        precondition(
+            buffer.count == shape.reduce(1, *),
+            "The scalar count of the buffer does not match the shape.")
+        self.buffer = buffer
+        self.shape = shape
+        debugLog("Done initializing ShapedArray from TensorBuffer.")
+    }
+}
+
+fileprivate extension ShapedArray {
+    mutating func ensureUniquelyReferenced() {
+        if isKnownUniquelyReferenced(&buffer) { return }
+        let oldBuffer = buffer
+        debugLog("Unique reference check")
+        buffer = TensorBuffer.create(count: scalarCount) { bufferPointer in
+            let pointer = bufferPointer.baseAddress!
+            oldBuffer.withUnsafeBufferPointer { oldBufferPointer in
+                let oldPointer = oldBufferPointer.baseAddress!
+                pointer.initialize(from: oldPointer, count: scalarCount)
+            }
+        }
+    }
+}
+
+internal extension ShapedArray where Scalar: _TensorFlowDataTypeCompatible {
+    @usableFromInline
+    init(owning cTensor: CTensor) {
+        // Including \(Scalar.self) into the message would cause non-deterministic crashes.
+        debugLog("Initializing ShapedArray from CTensor.")
+        shape = (0..<TF_NumDims(cTensor)).map { Int(TF_Dim(cTensor, $0)) }
+        if _RuntimeConfig.printsDebugLog {
+            // Without this local variable, passing the string directly into debugLog() would not 
+            // work, because 'self' is captured by the auto closure param in debugLog().
+            let shapeStr = "The shape is \(shape)."
+            debugLog(shapeStr)
+        }
+        buffer = TensorBuffer(owning: cTensor, count: shape.reduce(1, *))
+        debugLog("Done initializing ShapedArray from CTensor.")
+    }
+
+    @usableFromInline
+    @inline(never)
+    init(cTensorHandle: CTensorHandle) {
+        internalConsistencyCheck(TFE_TensorHandleIsConcrete(cTensorHandle) != 0)
+        let status = TF_NewStatus()
+        let cTensor = TFE_TensorHandleResolve(cTensorHandle, status)
+        checkOk(status)
+        TF_DeleteStatus(status)
+        internalConsistencyCheck(cTensor != nil)
+        debugLog("# of dims is \(TF_NumDims(cTensor!))")
+        debugLog("Returning a shaped array.")
+        self.init(owning: cTensor!)
+    }
+}
+
+public extension ShapedArray {
+    /// The number of dimensions of the array.
+    var rank: Int {
+        return shape.count
+    }
+
+    /// The total number of scalars in the array.
+    var scalarCount: Int {
+        return buffer.count
+    }
+
+    /// Creates a `ShapedArray` with the same shape and scalars as the specified instance.
+    init(_ other: ShapedArray) {
+        debugLog("Initializing from another ShapedArray.")
+        self.init(buffer: other.buffer, shape: other.shape)
+    }
+
+    /// Creates a `ShapedArray` with the specified shape and contiguous scalars in row-major order.
+    /// - Precondition: The number of scalars must equal the product of the dimensions of the shape.
+    init(shape: __owned [Int], scalars: __owned [Scalar]) {
+        precondition(shape.reduce(1, *) == scalars.count, "Scalar count mismatch.")
+        let buffer = TensorBuffer<Scalar>(allocation: .native(.init(scalars)), count: scalars.count)
+        self.init(buffer: buffer, shape: shape)
+    }
+
+    /// Creates a `ShapedArray` with the specified shape and sequence of scalars in row-major order.
+    /// - Precondition: The number of scalars must equal the product of the dimensions of the shape.
+    init<S: Sequence>(shape: __owned [Int], scalars: __shared S) where S.Element == Scalar {
+        let scalarCount = shape.reduce(1, *)
+        let buffer = TensorBuffer<Scalar>.create(count: scalarCount) { bufferPointer in
+            let pointer = bufferPointer.baseAddress!
+            // TODO: Refactor with better pointer initializers in Swift 4.1.
+            var i = 0
+            for scalar in scalars {
+                guard i < scalarCount else { break }
+                pointer.advanced(by: i).initialize(to: scalar)
+                i += 1
+            }
+            // If the sequence has fewer elements than the shape needs, this is a precondition
+            // failure.
+            precondition(
+                i == scalarCount,
+                "The sequence has fewer elements than needed by the shape.")
+        }
+        self.init(buffer: buffer, shape: shape)
+    }
+
+    /// Creates a `ShapedArray` from a scalar value.
+    init(_ scalar: __owned Scalar) {
+        self.init(buffer: TensorBuffer(allocation: .native(.init([scalar])), count: 1), shape: [])
+    }
+
+    /// Creates a `ShapedArray` with the specified shape and a single, repeated scalar value.
+    /// - Parameters:
+    ///   - shape: The shape of the `ShapedArray`.
+    ///   - repeatedValue: The scalar value to repeat.
+    @inlinable @inline(__always)
+    @available(*, deprecated, renamed: "init(repeating:shape:)")
+    init(shape: __owned [Int], repeating repeatedValue: __owned Scalar) {
+        self.init(repeating: repeatedValue, shape: shape)
+    }
+
+    /// Creates a `ShapedArray` with the specified shape and a single, repeated scalar value.
+    /// - Parameters:
+    ///   - repeatedValue: The scalar value to repeat.
+    ///   - shape: The shape of the `ShapedArray`.
+    init(repeating repeatedValue: __owned Scalar, shape: __owned [Int]) {
+        let scalarCount = shape.reduce(1, *)
+        let buffer = TensorBuffer<Scalar>(
+            allocation: .native(.init(Array(repeating: repeatedValue, count: scalarCount))),
+            count: scalarCount)
+        self.init(buffer: buffer, shape: shape)
+    }
+}
+
+extension ShapedArray: RandomAccessCollection, MutableCollection {
+    public typealias Index = Int
+    public typealias Element = ShapedArraySlice<Scalar>
+    public typealias SubSequence = ShapedArraySlice<Scalar>
+
+    public var indices: Range<Int> {
+        return 0..<count
+    }
+
+    public var startIndex: Int {
+        return 0
+    }
+
+    public var endIndex: Int {
+        return count
+    }
+
+    /// Access the element array specified by an index in the leading dimension.
+    /// - Parameter index: Index of the element array.
+    public subscript(index: Int) -> Element {
+        get {
+            precondition(!isScalar, "Scalar has no elements and cannot be subscripted.")
+            precondition(index < endIndex, "ShapedArray index is out of range")
+            precondition(index >= startIndex, "Negative ShapedArray index is out of range")
+            return ShapedArraySlice(base: self, baseIndices: [index])
+        }
+        set {
+            precondition(!isScalar, "Scalar has no elements and cannot be subscripted.")
+            precondition(index < endIndex, "ShapedArray index is out of range")
+            precondition(index >= startIndex, "Negative ShapedArray index is out of range")
+            precondition(shape.dropFirst().elementsEqual(newValue.shape), "Element shape mismatch")
+            let scalarIndex = self.scalarIndex(fromIndex: index)
+            withUnsafeMutableBufferPointer { destBuffPtr in
+                let ptr = destBuffPtr.baseAddress!.advanced(by: scalarIndex)
+                newValue.withUnsafeBufferPointer { srcBuffPtr in
+                    ptr.initialize(from: srcBuffPtr.baseAddress!, count: srcBuffPtr.count)
+                }
+            }
+        }
+    }
+
+    /// Access the subarray specified by a contiguous range of indices.
+    /// - Parameter bounds: Contiguous range of indices.
+    public subscript(bounds: Range<Int>) -> SubSequence {
+        get {
+            precondition(!isScalar, "Scalar has no elements and cannot be subscripted.")
+            precondition(
+                bounds.lowerBound >= startIndex && bounds.lowerBound <= endIndex &&
+                bounds.upperBound >= startIndex && bounds.upperBound <= endIndex,
+                "ShapedArray indices are out of range")
+            return ShapedArraySlice(base: self, bounds: bounds)
+        }
+        set {
+            precondition(!isScalar, "Scalar has no elements and cannot be subscripted.")
+            precondition(
+                indices ~= bounds.lowerBound && indices ~= bounds.upperBound - 1,
+                "ShapedArray indices are out of range.")
+            let subArrayShape = [bounds.count] + shape.dropFirst()
+            precondition(subArrayShape == newValue.shape, "Subarray shape mismatch.")
+            let scalarIndex = self.scalarIndex(fromIndex: bounds.lowerBound)
+            withUnsafeMutableBufferPointer { destBuffPtr in
+                let ptr = destBuffPtr.baseAddress!.advanced(by: scalarIndex)
+                newValue.withUnsafeBufferPointer { srcBuffPtr in
+                    ptr.initialize(from: srcBuffPtr.baseAddress!, count: srcBuffPtr.count)
+                }
+            }
+        }
+    }
+}
+
+public extension ShapedArray {
+    /// Calls a closure with a pointer to the array’s contiguous storage.
+    /// - Parameter body: A closure with an `UnsafeBufferPointer` parameter that points to the 
+    ///   contiguous storage for the array. If no such storage exists, it is created. If body has a 
+    ///   return value, that value is also used as the return value for the 
+    ///   `withUnsafeBufferPointer(_:)` method. The pointer argument is valid only for the duration 
+    ///   of the method's execution.
+    func withUnsafeBufferPointer<Result>(
+        _ body: (UnsafeBufferPointer<Scalar>) throws -> Result
+    ) rethrows -> Result {
+        return try buffer.withUnsafeBufferPointer { ptr in try body(ptr) }
+    }
+
+    /// Calls the given closure with a pointer to the array’s mutable contiguous storage.
+    /// - Parameter body: A closure with an `UnsafeMutableBufferPointer` parameter that points to 
+    ///   the contiguous storage for the array. If no such storage exists, it is created. If body 
+    ///   has a return value, that value is also used as the return value for the
+    ///   `withUnsafeMutableBufferPointer(_:)` method. The pointer argument is valid only for the 
+    ///   duration of the method's execution.
+    mutating func withUnsafeMutableBufferPointer<Result>(
+        _ body: (inout UnsafeMutableBufferPointer<Scalar>) throws -> Result
+    ) rethrows -> Result {
+        ensureUniquelyReferenced()
+        return try buffer.withUnsafeMutableBufferPointer { ptr in try body(&ptr) }
+    }
+}
+
+// Tensor conversion.
+extension ShapedArray where Scalar: TensorFlowScalar {
+    var byteCount: Int {
+        return MemoryLayout<Scalar>.stride * scalarCount
+    }
+
+    @usableFromInline
+    __consuming func makeTensorHandle() -> TensorHandle<Scalar> {
+        // This initializer is designed to optimize conversion from TF-allocated
+        // `ShapedArray` instances.
+        switch buffer.allocation {
+        case let .native(box):
+            precondition(
+                rank <= Int32.max,
+                "Conversion to TensorHandle is undefined when rank exceeds `Int32.max`.")
+            precondition(
+                shape.allSatisfy { $0 <= Int32.max },
+                "Conversion to TensorHandle is undefined when shape dimensions exceed `Int32.max`.")
+            return TensorHandle<Scalar>(
+                shape: shape,
+                scalarsInitializer: { addr in 
+                    addr.initialize(from: box.array, count: scalarCount)
+                })
+        case let .tensorFlow(cTensor):
+            return TensorHandle(copyingFromCTensor: cTensor)
+        }
+    }
+}
+
+// Tensor conversion.
+public extension Tensor {
+    init(_ array: __owned ShapedArray<Scalar>) {
+        self.init(handle: array.makeTensorHandle())
+    }
+}
+
+// Array literal conversion.
+extension ShapedArray: ExpressibleByArrayLiteral where Scalar: TensorFlowScalar {
+    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
+    @inlinable @inline(__always)
+    public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...) {
+        self = Tensor<Scalar>(_tensorElementLiterals: elements).array
+    }
+}
+
+// Equatable conformance.
+extension ShapedArray: Equatable where Scalar: Equatable {
+    public static func == (lhs: ShapedArray, rhs: ShapedArray) -> Bool {
+        return lhs._isEqual(to: rhs)
+    }
+}
+
+// Hashable conformance.
+extension ShapedArray: Hashable where Scalar: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(shape)
+        hasher.combine(scalars)
+    }
+}
+
+// String conversion.
+extension ShapedArray: CustomStringConvertible {
+    /// A textual representation of this `ShapedArray`.
+    ///
+    /// - Note: use `fullDescription` for a non-pretty-printed description showing all scalars.
+    public var description: String {
+        // Summarize if there are more than 1000 scalars.
+        let summarizing = scalarCount > 1000
+        return description(summarizing: summarizing)
+    }
+}
+
+// Xcode Playground display conversion.
+extension ShapedArray: CustomPlaygroundDisplayConvertible {
+    public var playgroundDescription: Any {
+        return description
+    }
+}
+
+// Mirror representation, used by debugger/REPL.
+extension ShapedArray: CustomReflectable {
+    public var customMirror: Mirror {
+        return Mirror(self, children: [], displayStyle: .struct)
+    }
+}
+
+// Codable conformance.
+extension ShapedArray: Codable where Scalar: Codable {
+    private enum CodingKeys: String, CodingKey {
+        case shape
+        case scalars
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let shape = try container.decode([Int].self, forKey: .shape)
+        let scalars = try container.decode([Scalar].self, forKey: .scalars)
+        self.init(shape: shape, scalars: scalars)
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(shape, forKey: .shape)
+        try container.encode(scalars, forKey: .scalars)
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// ShapedArraySlice
+//===------------------------------------------------------------------------------------------===//
+
+/// A contiguous slice of a `ShapedArray` or `ShapedArraySlice` instance.
+///
+/// `ShapedArraySlice` enables fast, efficient operations on contiguous slices of `ShapedArray` 
+/// instances. `ShapedArraySlice` instances do not have their own storage. Instead, they provides a 
+/// view onto the storage of their base `ShapedArray`. `ShapedArraySlice` can represent two 
+/// different kinds of slices: element arrays and subarrays.
+///
+/// Element arrays are subdimensional elements of a `ShapedArray`: their rank is one less than that 
+/// of their base. Element array slices are obtained by indexing a `ShapedArray` instance with a 
+/// singular `Int32` index.
+///
+/// For example:
+/// ```
+///     var matrix = ShapedArray(shape: [2, 2], scalars: [0, 1, 2, 3])
+///     // `matrix` represents [[0, 1], [2, 3]].
+///
+///     let element = matrix[0]
+///     // `element` is a `ShapedArraySlice` with shape [2]. It is an element
+///     // array, specifically the first element in `matrix`: [0, 1].
+///
+///     matrix[1] = ShapedArraySlice(shape: [2], scalars: [4, 8])
+///     // The second element in `matrix` has been mutated.
+///     // `matrix` now represents [[0, 1, 4, 8]].
+/// ```
+///
+/// Subarrays are a contiguous range of the elements in a `ShapedArray`. The rank of a subarray is 
+/// the same as that of its base, but its leading dimension is the count of the slice range. 
+/// Subarray slices are obtained by indexing a `ShapedArray` with a `Range<Int32>` that represents a 
+/// range of elements (in the leading dimension). Methods like `prefix(:)` and `suffix(:)` that
+/// internally index with a range also produce subarray.
+///
+/// For example:
+/// ```
+///     let zeros = ShapedArray(repeating: 0, shape: [3, 2])
+///     var matrix = ShapedArray(shape: [3, 2], scalars: Array(0..<6))
+///     // `zeros` represents [[0, 0], [0, 0], [0, 0]].
+///     // `matrix` represents [[0, 1], [2, 3], [4, 5]].
+///
+///     let subarray = matrix.prefix(2)
+///     // `subarray` is a `ShapedArraySlice` with shape [2, 2]. It is a slice
+///     // of the first 2 elements in `matrix` and represents [[0, 1], [2, 3]].
+///
+///     matrix[0..<2] = zeros.prefix(2)
+///     // The first 2 elements in `matrix` have been mutated.
+///     // `matrix` now represents [[0, 0], [0, 0], [4, 5]].
+/// ```
+@_fixed_layout
+public struct ShapedArraySlice<Scalar>: _ShapedArrayProtocol {
+    /// The underlying `ShapedArray` of the slice.
+    @usableFromInline internal var base: ShapedArray<Scalar>
+    /// The subdimensional indices of a slice.
+    @usableFromInline internal var baseIndices: [Int]
+    /// The subarray bounds of a slice.
+    @usableFromInline internal var bounds: Range<Int>?
+
+    /// Creates a `ShapedArraySlice` from a base `ShapedArray`, with the specified subdimensional
+    /// indices and subarray bounds.
+    @inlinable
+    internal init(
+        base: __owned ShapedArray<Scalar>,
+        baseIndices indices: __owned [Int] = [],
+        bounds: Range<Int>? = nil
+    ) {
+        precondition(indices.count <= base.rank, "Number of base indices exceeds base rank")
+        precondition(
+            zip(base.shape, indices).allSatisfy { $1 >= 0 && $1 < $0 },
+            "Base indices are out of range")
+        self.base = base
+        self.baseIndices = indices
+        self.bounds = bounds
+    }
+}
+
+public extension ShapedArraySlice {
+    /// Indexing depth of this slice, i.e. the difference in rank between the base and the slice.
+    internal var indexingDepth: Int {
+        return baseIndices.count
+    }
+
+    /// The number of dimensions of the array.
+    var rank: Int {
+        return base.rank - indexingDepth
+    }
+
+    /// The shape of the array.
+    var shape: [Int] {
+        if let bounds = bounds {
+            return [bounds.count] + Array(base.shape.dropFirst(indexingDepth + 1))
+        }
+        return Array(base.shape.dropFirst(indexingDepth))
+    }
+
+    /// The total number of scalars in the array.
+    var scalarCount: Int {
+        return shape.reduce(1, *)
+    }
+}
+
+// Slice initializers.
+public extension ShapedArraySlice {
+    /// Creates a `ShapedArraySlice` with the specified shape and contiguous scalars in row-major
+    /// order.
+    /// - Precondition: The number of scalars must equal the product of the dimensions of the shape.
+    init(shape: __owned [Int], scalars: __owned [Scalar]) {
+        self.init(base: ShapedArray(shape: shape, scalars: scalars))
+    }
+
+    /// Creates an `ShapedArraySlice` with the specified shape and sequence of scalars in row-major
+    /// order.
+    /// - Precondition: The number of scalars must equal the product of the dimensions of the shape.
+    init<S: Sequence>(shape: __owned [Int], scalars: __shared S) where S.Element == Scalar {
+        self.init(base: ShapedArray(shape: shape, scalars: scalars))
+    }
+
+    /// Creates a `ShapedArraySlice` from a scalar value.
+    init(_ scalar: __owned Scalar) {
+        self.init(base: ShapedArray(scalar))
+    }
+
+    /// Creates a `ShapedArraySlice` with the specified shape and a single, repeated scalar value.
+    /// - Parameters:
+    ///   - repeatedValue: The scalar value to repeat.
+    ///   - shape: The shape of the `ShapedArraySlice`.
+    @inlinable @inline(__always)
+    @available(*, deprecated, renamed: "init(repeating:shape:)")
+    init(shape: __owned [Int], repeating repeatedValue: __owned Scalar) {
+        self.init(repeating: repeatedValue, shape: shape)
+    }
+
+    /// Creates a `ShapedArraySlice` with the specified shape and a single, repeated scalar value.
+    /// - Parameters:
+    ///   - repeatedValue: The scalar value to repeat.
+    ///   - shape: The shape of the `ShapedArraySlice`.
+    init(repeating repeatedValue: __owned Scalar, shape: __owned [Int]) {
+        self.init(base: ShapedArray(repeating: repeatedValue, shape: shape))
+    }
+}
+
+internal extension ShapedArraySlice {
+    /// The range of scalars from the base `ShapedArray` represented by a `ShapedArraySlice`.
+    var scalarRange: Range<Int> {
+        let trimmedShape = base.shape.dropFirst()
+        var (start, end) = baseIndices.enumerated().reduce((0, base.scalarCount)) { (acc, next) in
+            let stride = trimmedShape.dropFirst(next.offset).reduce(1, *)
+            if next.offset == indexingDepth - 1 {
+                let temp = acc.0 + next.element * stride
+                return (temp, temp + stride)
+            }
+            return (acc.0 + next.element * stride, acc.1)
+        }
+        if let bounds = bounds {
+            let stride = trimmedShape.dropFirst(indexingDepth).reduce(1, *)
+            let oldStart = start
+            start = start + bounds.startIndex * stride
+            end = oldStart + bounds.endIndex * stride
+        }
+        return start..<end
+    }
+}
+
+public extension ShapedArraySlice {
+    /// Calls a closure with a pointer to the `ShapedArraySlice`’s contiguous storage.
+    /// - Parameter body: A closure with an `UnsafeBufferPointer` parameter that points to the 
+    ///   contiguous storage for the `ShapedArraySlice`. If no such storage exists, it is created.
+    ///   If body has a return value, that value is also used as the return value for the
+    ///   `withUnsafeBufferPointer(_:)` method. The pointer argument is valid only for the duration 
+    ///   of the method's execution.
+    func withUnsafeBufferPointer<Result>(
+        _ body: (UnsafeBufferPointer<Scalar>) throws -> Result
+    ) rethrows -> Result {
+        return try base.withUnsafeBufferPointer { baseBuffPtr in
+            let basePtr = baseBuffPtr.baseAddress!
+            let ptr = UnsafeBufferPointer(
+                start: basePtr.advanced(by: scalarRange.startIndex),
+                count: scalarRange.count)
+            return try body(ptr)
+        }
+    }
+
+    /// Calls the given closure with a pointer to the `ShapedArraySlice`'s mutable contiguous
+    /// storage.
+    /// - Parameter body: A closure with an `UnsafeMutableBufferPointer` parameter that points to
+    ///   the contiguous storage for the `ShapedArraySlice`. If no such storage exists, it is 
+    ///   created. If body has a return value, that value is also used as the return value for the
+    ///   `withUnsafeMutableBufferPointer(_:)` method. The pointer argument is valid only for the
+    ///   duration of the method’s execution.
+    mutating func withUnsafeMutableBufferPointer<Result>(
+        _ body: (inout UnsafeMutableBufferPointer<Scalar>) throws -> Result
+    ) rethrows -> Result {
+        // NOTE: Copying `scalarRange` to a local variable here is necessary for
+        // exclusive access.
+        let scalarRange = self.scalarRange
+        return try base.withUnsafeMutableBufferPointer { baseBuffPtr in
+            let basePtr = baseBuffPtr.baseAddress!
+            var ptr = UnsafeMutableBufferPointer(
+                start: basePtr.advanced(by: scalarRange.startIndex),
+                count: scalarRange.count)
+            return try body(&ptr)
+        }
+    }
+}
+
+extension ShapedArraySlice: RandomAccessCollection, MutableCollection {
+    public typealias Index = Int
+    public typealias Element = ShapedArraySlice
+    public typealias SubSequence = ShapedArraySlice
+
+    public var indices: Range<Int> {
+        if let bounds = bounds {
+            return bounds
+        } else if indexingDepth < base.rank {
+            return 0..<base.shape[indexingDepth]
+        }
+        return 0..<0
+    }
+
+    public var startIndex: Int {
+        return indices.startIndex
+    }
+
+    public var endIndex: Int {
+        return indices.endIndex
+    }
+
+    /// Access the element array specified by an index in the leading dimension.
+    /// - Parameter index: Index of the element array.
+    public subscript(index: Int) -> Element {
+        get {
+            precondition(!isScalar, "Scalar has no elements and cannot be subscripted.")
+            precondition(index < endIndex, "ShapedArraySlice index is out of range.")
+            precondition(
+                index >= startIndex,
+                "ShapeArraySlice index is out of range (before startIndex).")
+            return ShapedArraySlice(base: base, baseIndices: baseIndices + [index], bounds: nil)
+        }
+        set {
+            precondition(!isScalar, "Scalar has no elements and cannot be subscripted.")
+            precondition(index < endIndex, "ShapedArraySlice index is out of range")
+            precondition(
+                index >= startIndex,
+                "ShapeArraySlice index is out of range (before startIndex).")
+            precondition(shape.dropFirst().elementsEqual(newValue.shape), "Element shape mismatch.")
+            let scalarIndex = self.scalarIndex(fromIndex: index)
+            withUnsafeMutableBufferPointer { destBuffPtr in
+                let ptr = destBuffPtr.baseAddress!.advanced(by: scalarIndex)
+                newValue.withUnsafeBufferPointer { srcBuffPtr in
+                    ptr.initialize(from: srcBuffPtr.baseAddress!, count: srcBuffPtr.count)
+                }
+            }
+        }
+    }
+
+    /// Access the subarray specified by a contiguous range of indices.
+    /// - Parameter bounds: Contiguous range of indices.
+    public subscript(bounds: Range<Int>) -> SubSequence {
+        get {
+            precondition(!isScalar, "Scalar has no elements and cannot be subscripted.")
+            precondition(
+                indices ~= bounds.lowerBound && indices ~= bounds.upperBound - 1,
+                "ShapedArraySlice indices are out of range.")
+            return ShapedArraySlice(base: base, baseIndices: baseIndices, bounds: bounds)
+        }
+        set {
+            precondition(!isScalar, "Scalar has no elements and cannot be subscripted.")
+            precondition(
+                indices ~= bounds.lowerBound && indices ~= bounds.upperBound - 1,
+                "ShapedArraySlice indices are out of range.")
+            let subArrayShape = [bounds.count] + shape.dropFirst()
+            precondition(subArrayShape == newValue.shape, "Subarray shape mismatch.")
+            let scalarIndex = self.scalarIndex(fromIndex: bounds.lowerBound)
+            withUnsafeMutableBufferPointer { destBuffPtr in
+                let ptr = destBuffPtr.baseAddress!.advanced(by: scalarIndex)
+                newValue.withUnsafeBufferPointer { srcBuffPtr in
+                    ptr.initialize(from: srcBuffPtr.baseAddress!, count: srcBuffPtr.count)
+                }
+            }
+        }
+    }
+}
+
+// Tensor conversion.
+public extension ShapedArraySlice where Scalar: TensorFlowScalar {
+    init(_ tensor: __shared Tensor<Scalar>) {
+        self.init(base: tensor.array)
+    }
+}
+
+// Array literal conversion.
+extension ShapedArraySlice: ExpressibleByArrayLiteral where Scalar: TensorFlowScalar {
+    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
+    @inlinable @inline(__always)
+    public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...) {
+        self.init(base: Tensor(_tensorElementLiterals: elements).array)
+    }
+}
+
+// Equatable conformance.
+extension ShapedArraySlice: Equatable where Scalar: Equatable {
+    public static func == (lhs: ShapedArraySlice, rhs: ShapedArraySlice) -> Bool {
+        return lhs._isEqual(to: rhs)
+    }
+}
+
+// Hashable conformance.
+extension ShapedArraySlice: Hashable where Scalar: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(shape)
+        hasher.combine(scalars)
+    }
+}
+
+// String conversion.
+extension ShapedArraySlice: CustomStringConvertible {
+    /// A textual representation of this `ShapedArraySlice`.
+    ///
+    /// - Note: use `fullDescription` for a non-pretty-printed representation showing all scalars.
+    public var description: String {
+        // Summarize if there are more than 1000 scalars.
+        let summarizing = scalarCount > 1000
+        return description(summarizing: summarizing)
+    }
+}
+
+// Xcode Playground display conversion.
+extension ShapedArraySlice: CustomPlaygroundDisplayConvertible {
+    public var playgroundDescription: Any {
+        return description
+    }
+}
+
+// Mirror representation, used by debugger/REPL.
+extension ShapedArraySlice: CustomReflectable {
+    public var customMirror: Mirror {
+        return Mirror(self, children: [], displayStyle: .struct)
+    }
+}
+
+// Codable conformance.
+extension ShapedArraySlice: Codable where Scalar: Codable {
+    private enum CodingKeys: String, CodingKey {
+        case shape
+        case scalars
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(shape, forKey: .shape)
+        try container.encode(scalars, forKey: .scalars)
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let shape = try container.decode([Int].self, forKey: .shape)
+        let scalars = try container.decode([Scalar].self, forKey: .scalars)
+        self.init(shape: shape, scalars: scalars)
+    }
+}
+
+fileprivate extension _ShapedArrayProtocol where Scalar: Equatable {
+    func _isEqual(to other: Self) -> Bool {
+        return shape == other.shape && withUnsafeBufferPointer { selfBuf in
+            other.withUnsafeBufferPointer { otherBuf in
+                selfBuf.elementsEqual(otherBuf)
+            }
+        }
+    }
+}
diff --git a/Sources/DeepLearning/Core/StringTensor.swift b/Sources/DeepLearning/Core/StringTensor.swift
new file mode 100644
index 000000000..d67b0574c
--- /dev/null
+++ b/Sources/DeepLearning/Core/StringTensor.swift
@@ -0,0 +1,70 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+import CTensorFlow
+import TensorFlowCore
+
+//===------------------------------------------------------------------------------------------===//
+// StringTensor
+//===------------------------------------------------------------------------------------------===//
+
+/// `StringTensor` is a multi-dimensional array whose elements are `String`s.
+@_fixed_layout
+public struct StringTensor {
+    /// The underlying `TensorHandle`.
+    /// - Note: `handle` is public to allow user defined ops, but should not normally be used
+    ///   otherwise.
+    public let handle: TensorHandle<String>
+
+    @inlinable
+    public init(handle: TensorHandle<String>) {
+        self.handle = handle
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// Initialization
+//===------------------------------------------------------------------------------------------===//
+
+public extension StringTensor {
+    /// Creates a tensor from a scalar value.
+    @inlinable @inline(__always)
+    init(_ value: String) {
+        self.init(handle: _TFStringTensorFromString(value))
+    }
+
+    /// Creates a 1D tensor from contiguous scalars.
+    ///
+    /// - Parameters:
+    ///   - vector: The scalar contents of the tensor.
+    @inlinable @inline(__always)
+    init(_ vector: [String]) {
+        self.init(handle: _TFStringTensorFromStrings1D(vector))
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// Array Conversion
+//===------------------------------------------------------------------------------------------===//
+
+public extension StringTensor {
+    var array: ShapedArray<String> {
+        debugLog("Returning a host copy of string array.")
+        return handle.makeHostCopy()
+    }
+
+    var scalars: [String] {
+        return array.scalars
+    }
+}
diff --git a/Sources/DeepLearning/Core/Tensor.swift b/Sources/DeepLearning/Core/Tensor.swift
new file mode 100644
index 000000000..90669442c
--- /dev/null
+++ b/Sources/DeepLearning/Core/Tensor.swift
@@ -0,0 +1,645 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+import TensorFlowCore
+
+infix operator .==: ComparisonPrecedence
+infix operator .!=: ComparisonPrecedence
+
+/// `Tensor` is a multi-dimensional array used for computation. It is a wrapper around a 
+/// `TensorHandle`.
+@_fixed_layout
+public struct Tensor<Scalar: TensorFlowScalar>: TensorProtocol {
+    /// The underlying `TensorHandle`.
+    /// - Note: `handle` is public to allow user defined ops, but should not normally be used.
+    public let handle: TensorHandle<Scalar>
+
+    @inlinable
+    public init(handle: TensorHandle<Scalar>) {
+        self.handle = handle
+    }
+}
+
+extension Tensor: AnyTensor {
+    public var _rawTensorHandle: CTensorHandle { return handle._cTensorHandle }
+    public var _tensorFlowDataType: TensorDataType { return Scalar.tensorFlowDataType }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// Tensor Properties
+//===------------------------------------------------------------------------------------------===//
+
+public extension Tensor {
+    /// The number of dimensions of the `Tensor`.
+    @inlinable
+    var rank: Int {
+        @inline(__always)
+        @_semantics("autodiff.nonvarying")
+        get {
+            return Int(_TFGetScalarOrDie(rankTensor.handle))
+        }
+    }
+
+    /// The dimensions of the `Tensor`.
+    @inlinable
+    var shape: TensorShape {
+        @inline(__always)
+        @_semantics("autodiff.nonvarying")
+        get {
+            return TensorShape(shapeTensor.scalars.map(Int.init))
+        }
+    }
+
+    /// The number of scalars in the `Tensor`.
+    @inlinable
+    var scalarCount: Int {
+        @inline(__always)
+        get {
+            return Int(_TFGetScalarOrDie(scalarCountTensor.handle))
+        }
+    }
+
+    /// The rank of the tensor, represented as a `Tensor<Int32>`.
+    @inlinable
+    var rankTensor: Tensor<Int32> {
+        @_semantics("autodiff.nonvarying")
+        get {
+            return Raw.rank(self)
+        }
+    }
+
+    /// The dimensions of the tensor, represented as a `Tensor<Int32>`.
+    @inlinable
+    var shapeTensor: Tensor<Int32> {
+        @_semantics("autodiff.nonvarying")
+        get {
+            return Raw.shape(self)
+        }
+    }
+
+    /// The number of scalars in the tensor, represented as a `Tensor<Int32>`.
+    @inlinable
+    var scalarCountTensor: Tensor<Int32> {
+        @_semantics("autodiff.nonvarying")
+        get {
+            return Raw.size(self)
+        }
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// Scalar Conversion
+//===------------------------------------------------------------------------------------------===//
+
+public extension Tensor {
+    /// Returns `true` if `rank` is equal to 0 and `false` otherwise.
+    @inlinable
+    var isScalar: Bool {
+        @inline(__always)
+        get {
+            return rank == 0
+        }
+    }
+
+    /// Returns the single scalar element if `rank` is equal to 0 and `nil`
+    /// otherwise.
+    @inlinable
+    var scalar: Scalar? {
+        @inline(__always)
+        get {
+            return Scalar(self)
+        }
+    }
+
+    /// Reshape to scalar.
+    /// - Precondition: The tensor has exactly one scalar.
+    @inlinable
+    @differentiable(wrt: self, vjp: _vjpScalarized where Scalar: TensorFlowFloatingPoint)
+    func scalarized() -> Scalar {
+        return _TFGetScalarOrDie(reshaped(to: []).handle)
+    }
+}
+
+internal extension Tensor where Scalar: TensorFlowFloatingPoint {
+    @inlinable
+    func _vjpScalarized() -> (Scalar, (Scalar) -> Tensor) {
+        return (scalarized(), { v in Tensor(v) })
+    }
+}
+
+public extension TensorFlowScalar {
+    @inlinable @inline(__always)
+    init?(_ tensor: Tensor<Self>) {
+        guard let scalar = _TFGetScalar(tensor.handle) else {
+            return nil
+        }
+        self = scalar
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// Array Conversion
+//===------------------------------------------------------------------------------------------===//
+
+public extension Tensor {
+    @inlinable
+    var array: ShapedArray<Scalar> {
+        @inline(__always)
+        get {
+            debugLog("Returning a host copy of array.")
+            internalConsistencyCheck(toHost().handle.isConcrete)
+
+            // This is considered to be a well known way to produce a copy to the host, so an 
+            // "implicit copy to host" warning should not be produced.
+            return toHost().handle.makeHostCopy()
+        }
+    }
+
+    @inlinable
+    var scalars: [Scalar] {
+        return array.scalars
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// Memory Transfer Markers
+//===------------------------------------------------------------------------------------------===//
+
+public extension Tensor {
+    /// Mark memory transfer to accelerator.
+    /// - Parameters:
+    ///   - shape: When sending the tensor to a TF XLA device (including TPU), must specify the 
+    ///     tensor shape as required by XLA compilation.
+    @inlinable @inline(__always)
+    func toAccelerator(shape: TensorShape) -> Tensor {
+        let tensor = toAccelerator()
+        // If the tensor is to be sent from host to TPU, the shape is specified on TF CPU first, 
+        // before TF CPU sends the tensor to TPU.
+        let ret: TensorHandle<Scalar> = #tfop(
+            "Identity",
+            tensor,
+            T$dtype: Scalar.tensorFlowDataType,
+            __shapes: [shape],
+            __device: "/job:localhost/replica:0/task:0/device:CPU:0")
+        return Tensor(handle: ret)
+    }
+
+    /// Mark memory transfer to accelerator.
+    @inlinable @inline(__always)
+    func toAccelerator() -> Tensor {
+        return Tensor(handle: _TFToAccelerator(handle))
+    }
+
+    /// Mark memory transfer to host.
+    /// - Parameters:
+    ///   - shape: When sending the tensor to a TF XLA device (including TPU), must specify the 
+    ///     tensor shape as required by XLA compilation.
+    @inlinable @inline(__always)
+    func toHost(shape: TensorShape) -> Tensor {
+        // If the `self` tensor resides on TPU, the shape is specified on that device first, before 
+        // outfeeding the tensor to CPU, a required step for sending the tensor to the host.
+        let tensor: TensorHandle<Scalar> = #tfop(
+            "Identity", self, T$dtype: Scalar.tensorFlowDataType, __shapes: [shape])
+        return Tensor(handle: tensor).toHost()
+    }
+
+    /// Mark memory transfer to host.
+    @inlinable @inline(__always)
+    func toHost() -> Tensor {
+        return Tensor(handle: _TFToHost(handle))
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// Initialization
+//===------------------------------------------------------------------------------------------===//
+
+public extension Tensor {
+    /// Creates a tensor from a scalar value.
+    @inlinable @inline(__always)
+    @differentiable(vjp: _vjpScalarInit where Scalar: TensorFlowFloatingPoint)
+    init(_ value: Scalar) {
+        self.init(handle: _TFTensorFromScalar(value))
+    }
+}
+
+internal extension Tensor where Scalar: TensorFlowFloatingPoint {
+    @inlinable
+    static func _vjpScalarInit(_ value: Scalar) -> (Tensor, (Tensor) -> Scalar) {
+        return (Tensor(value), { $0.scalarized() })
+    }
+}
+
+public extension Tensor {
+    /// Creates a 1D tensor from contiguous scalars.
+    ///
+    /// - Parameters:
+    ///   - vector: The scalar contents of the tensor.
+    @inlinable @inline(__always)
+    init(_ vector: [Scalar]) {
+        self.init(handle: _TFTensorFromScalars1D(vector))
+    }
+
+    /// Creates a 1D tensor from contiguous scalars.
+    ///
+    /// - Parameters:
+    ///   - vector: The scalar contents of the tensor.
+    @inlinable @inline(__always)
+    init<C: RandomAccessCollection>(_ vector: C) where C.Element == Scalar {
+        let handle = _TFHoistable {
+        TensorHandle<Scalar>(
+            shape: [vector.count],
+            scalarsInitializer: { addr in
+                var currentAddr = addr
+                for scalar in vector {
+                    currentAddr.initialize(to: scalar)
+                    currentAddr = currentAddr.advanced(by: 1)
+                }
+            })
+        }
+        self.init(handle: handle)
+    }
+
+    /// Creates a tensor with the specified shape and contiguous scalars in row-major order.
+    ///
+    /// - Parameters:
+    ///   - shape: The shape of the tensor.
+    ///   - scalars: The scalar contents of the tensor.
+    /// - Precondition: The number of scalars must equal the product of the dimensions of the shape.
+    @inlinable @inline(__always)
+    init(shape: TensorShape, scalars: [Scalar]) {
+        // NOTE: We use `_TFTensorFromScalars` here so the compiler can try to promote constants and
+        // avoid copies.
+        self.init(handle: _TFTensorFromScalars(scalars, shape: shape.dimensions))
+    }
+
+    /// Creates a tensor with the specified shape and contiguous scalars in row-major order.
+    ///
+    /// - Parameters:
+    ///   - shape: The shape of the tensor.
+    ///   - scalars: The scalar contents of the tensor.
+    /// - Precondition: The number of scalars must equal the product of the
+    ///   dimensions of the shape.
+    @inlinable @inline(__always)
+    init(shape: TensorShape, scalars: UnsafeBufferPointer<Scalar>) {
+        let handle: TensorHandle<Scalar> = _TFHoistable {
+            precondition(scalars.count == shape.contiguousSize)
+            return TensorHandle<Scalar>(
+                shape: shape.dimensions,
+                scalarsInitializer: { address in
+                    address.initialize(from: scalars.baseAddress!, count: shape.contiguousSize)
+                })
+        }
+        self.init(handle: handle)
+    }
+
+    /// Creates a tensor with the specified shape and contiguous scalars in row-major order.
+    ///
+    /// - Parameters:
+    ///   - shape: The shape of the tensor.
+    ///   - scalars: The scalar contents of the tensor.
+    /// - Precondition: The number of scalars must equal the product of the
+    ///   dimensions of the shape.
+    @inlinable @inline(__always)
+    init<C: RandomAccessCollection>(shape: TensorShape, scalars: C) where C.Element == Scalar {
+        let handle: TensorHandle<Scalar> = _TFHoistable {
+            precondition(scalars.count == shape.contiguousSize)
+            return TensorHandle<Scalar>(
+                shape: shape.dimensions,
+                scalarsInitializer: { addr in
+                    var currentAddr = addr
+                    for scalar in scalars {
+                        currentAddr.initialize(to: scalar)
+                        currentAddr = currentAddr.advanced(by: 1)
+                    }
+                })
+        }
+        self.init(handle: handle)
+    }
+}
+
+// Background story on `TensorElementLiteral` and why it's necessary:
+//
+// Very importantly, we want users to be able to implicitly convert an array
+// literal to a tensor. At first glance, a straightfoward implementation would
+// be conforming `Tensor` to `ExpressibleByArrayLiteral` with
+// `ExpressibleBy(Float|Int|Bool)Literal` as a base case. However, it is not
+// that simple. We have binary operators that take `(Tensor, Scalar)`, `(Scalar,
+// Tensor)` as well as `(Tensor, Tensor)`. When `Tensor`s are convertible from
+// both a scalar and an array literal, a scalar-tensor binary operator like `+`
+// will not type check.
+//
+// One way to work around it is to define all tensor-tensor operators in a
+// protocol extension, and all tensor-scalar and scalar-tensor operators on
+// concrete `Tensor`. Protocol extensions are less favorable than concrete
+// implementations, so the compiler will prefer the concrete implementation for
+// a scalar-tensor operation. However, this would cause enormous code bloat and
+// is entirely a hack.
+//
+// To resolve ambiguity, `Tensor` should not be expressible by scalar literal.
+// There's already a lightweight syntax for converting a scalar to a tensor:
+// `Tensor(x)`, so there is no strong need for implicit conversion. But we need
+// to find a way to give `ExpressibleByArrayLiteral` a base case: what would the
+// `ArrayLiteralElement` be if we want to support both `[1,2,3]` and `[[[1,2],
+// [1,2]]]`? In the first case the array literal element is an interger, while
+// in the second case the array literal itself should be a tensor. Based on this
+// observation, we come up with an intermediate type: `TensorElementLiteral` as
+// the `ArrayLiteralElement` of `Tensor`. By making `TensorElementLiteral`
+// expressible by both array literal and scalar literal, `Tensor` can now be
+// converted from an arbitrary-dimensional array literal.
+//
+// Due to protocol requirements, `TensorElementLiteral` has to be
+// public. It is never supposed to be used directly by any user, so the library
+// convention is to prepend an underscore to its name, making it
+// `_TensorElementLiteral`.
+//
+// It would be nice to be able to remove this type when we can systematically
+// resolve tensor-scalar/scalar-tensor op ambiguity someday, either through an
+// improved `Expressible` model, or by introducing an attribute to tell the type
+// checker which function to prefer when ambiguity occurs.
+
+/// Represents a literal element for conversion to a `Tensor`.
+///
+/// - Note: Do not ever use this API directly. This is implicitly created
+///   during the conversion from an array literal to a `Tensor`, and is purely
+///   for implementation purposes.
+@_fixed_layout
+public struct _TensorElementLiteral<Scalar>: TensorProtocol where Scalar: TensorFlowScalar {
+    @usableFromInline let tensor: Tensor<Scalar>
+
+    @inlinable
+    public var handle: TensorHandle<Scalar> {
+        return tensor.handle
+    }
+
+    @inlinable
+    public init(handle: TensorHandle<Scalar>) {
+        tensor = Tensor(handle: handle)
+    }
+}
+
+extension _TensorElementLiteral: ExpressibleByBooleanLiteral
+    where Scalar: ExpressibleByBooleanLiteral {
+    public typealias BooleanLiteralType = Scalar.BooleanLiteralType
+    @inlinable @inline(__always)
+    public init(booleanLiteral: BooleanLiteralType) {
+        tensor = Tensor(Scalar(booleanLiteral: booleanLiteral))
+    }
+}
+
+extension _TensorElementLiteral: ExpressibleByIntegerLiteral
+    where Scalar: ExpressibleByIntegerLiteral {
+    public typealias IntegerLiteralType = Scalar.IntegerLiteralType
+    @inlinable @inline(__always)
+    public init(integerLiteral: IntegerLiteralType) {
+        tensor = Tensor(Scalar(integerLiteral: integerLiteral))
+    }
+}
+
+extension _TensorElementLiteral: ExpressibleByFloatLiteral
+    where Scalar: ExpressibleByFloatLiteral {
+    public typealias FloatLiteralType = Scalar.FloatLiteralType
+    @inlinable @inline(__always)
+    public init(floatLiteral: FloatLiteralType) {
+        tensor = Tensor(Scalar(floatLiteral: floatLiteral))
+    }
+}
+
+extension _TensorElementLiteral: ExpressibleByArrayLiteral {
+    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
+    @inlinable @inline(__always)
+    public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...) {
+        // FIXME: We cannot use Raw.pack here because _TensorElementLiteral does not
+        // conform to tensor group and if we do, several partitioning tests fail.
+        self.init(handle: #tfop("Pack", elements, T$dtype: Scalar.tensorFlowDataType))
+    }
+}
+
+extension Tensor: ExpressibleByArrayLiteral {
+    /// The type of the elements of an array literal.
+    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
+
+    /// Creates a tensor initialized with the given elements.
+    /// - Note: This is for conversion from tensor element literals. This is a
+    /// separate method because `ShapedArray` initializers need to call it.
+    @inlinable @inline(__always)
+    internal init(_tensorElementLiterals elements: [_TensorElementLiteral<Scalar>]) {
+        // FIXME: We cannot use Raw.pack here because _TensorElementLiteral does not
+        // conform to tensor group and if we do, several partitioning tests fail.
+        self.init(handle: #tfop("Pack", elements, T$dtype: Scalar.tensorFlowDataType))
+    }
+
+    /// Creates a tensor initialized with the given elements.
+    @inlinable @inline(__always)
+    public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...) {
+        self.init(_tensorElementLiterals: elements)
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// Equatable
+//===------------------------------------------------------------------------------------------===//
+
+extension Tensor: Equatable where Scalar: Equatable {
+    @inlinable
+    public static func == (lhs: Tensor, rhs: Tensor) -> Bool {
+        // TODO: This is not correct due to broadcasting.
+        return (lhs .== rhs).all()
+    }
+
+    @inlinable
+    public static func != (lhs: Tensor, rhs: Tensor) -> Bool {
+        // TODO: This is not correct due to broadcasting.
+        return (lhs .!= rhs).any()
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// Description and Visualization
+//===------------------------------------------------------------------------------------------===//
+
+// String conversion.
+extension Tensor: CustomStringConvertible {
+    /// A textual representation of the tensor.
+    ///
+    /// - Note: use `fullDescription` for a non-pretty-printed description showing all scalars.
+    public var description: String {
+        @_semantics("autodiff.nonvarying")
+        get {
+            return array.description
+        }
+    }
+}
+
+public extension Tensor {
+    /// A textual representation of the tensor. Returns a summarized description if `summarize` is
+    /// true and the element count exceeds twice the `edgeElementCount`.
+    ///
+    /// - Parameters:
+    ///   - lineWidth: The max line width for printing. Used to determine number of scalars to print
+    ///     per line.
+    ///   - edgeElementCount: The maximum number of elements to print before and after summarization
+    ///     via ellipses (`...`).
+    ///   - summarizing: If true, summarize description if element count exceeds twice
+    ///     `edgeElementCount`.
+    func description(
+        lineWidth: Int = 80,
+        edgeElementCount: Int = 3,
+        summarizing: Bool = false
+    ) -> String {
+        return array.description(
+            lineWidth: lineWidth,
+            edgeElementCount: edgeElementCount,
+            summarizing: summarizing)
+    }
+
+    /// A full, non-pretty-printed textual representation of the tensor, showing
+    /// all scalars.
+    var fullDescription: String {
+        @_semantics("autodiff.nonvarying")
+        get {
+            return array.fullDescription
+        }
+    }
+}
+
+// Xcode Playground display conversion.
+extension Tensor: CustomPlaygroundDisplayConvertible {
+    public var playgroundDescription: Any {
+        @_semantics("autodiff.nonvarying")
+        get {
+            return description
+        }
+    }
+}
+
+// Mirror representation, used by debugger/REPL.
+extension Tensor: CustomReflectable {
+    public var customMirror: Mirror {
+        @_semantics("autodiff.nonvarying")
+        get {
+            return Mirror(self, children: [], displayStyle: .struct)
+        }
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// Codable Conformance
+//===------------------------------------------------------------------------------------------===//
+
+extension Tensor: Codable where Scalar: Codable {
+    @inlinable
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(array)
+    }
+
+    @inlinable
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        let array = try container.decode(ShapedArray<Scalar>.self)
+        self.init(array)
+    }
+}
+
+//===-------------------------------------------------------------------------------------------===//
+// Additive Group
+//===-------------------------------------------------------------------------------------------===//
+
+extension Tensor: AdditiveArithmetic where Scalar: Numeric {
+    /// A scalar zero tensor.
+    @inlinable
+    public static var zero: Tensor {
+        return Tensor(0)
+    }
+
+    /// Adds two tensors and produces their sum.
+    /// - Note: `+` supports broadcasting.
+    @inlinable @inline(__always)
+    @differentiable(vjp: _vjpAdd(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
+    public static func + (lhs: Tensor, rhs: Tensor) -> Tensor {
+        return Raw.add(lhs, rhs)
+    }
+
+    /// Subtracts one tensor from another and produces their difference.
+    /// - Note: `-` supports broadcasting.
+    @inlinable @inline(__always)
+    @differentiable(vjp: _vjpSubtract(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
+    public static func - (lhs: Tensor, rhs: Tensor) -> Tensor {
+        return Raw.sub(lhs, rhs)
+    }
+}
+
+internal extension Tensor where Scalar: TensorFlowFloatingPoint {
+    @inlinable
+    static func _vjpAdd(
+        lhs: Tensor,
+        rhs: Tensor
+    ) -> (Tensor, (Tensor) -> (Tensor, Tensor)) {
+        return (lhs + rhs, { [
+            lhsShape = lhs.shape,
+            rhsShape = rhs.shape,
+            lhsShapeTensor = lhs.shapeTensor,
+            rhsShapeTensor = rhs.shapeTensor] v in
+            var lhsGrad = v
+            var rhsGrad = v
+            if lhsGrad.shape != lhsShape {
+                lhsGrad = lhsGrad.unbroadcasted(toShape: lhsShapeTensor)
+            }
+            if rhsGrad.shape != rhsShape {
+                rhsGrad = rhsGrad.unbroadcasted(toShape: rhsShapeTensor)
+            }
+            return (lhsGrad, rhsGrad)
+        })
+    }
+
+    @inlinable
+    static func _vjpSubtract(
+        lhs: Tensor,
+        rhs: Tensor
+    ) -> (Tensor, (Tensor) -> (Tensor, Tensor)) {
+        return (lhs - rhs, { [
+            lhsShape = lhs.shape,
+            rhsShape = rhs.shape,
+            lhsShapeTensor = lhs.shapeTensor,
+            rhsShapeTensor = rhs.shapeTensor] v in
+            var lhsGrad = v
+            var rhsGrad = -v
+            if lhsGrad.shape != lhsShape {
+                lhsGrad = lhsGrad.unbroadcasted(toShape: lhsShapeTensor)
+            }
+            if rhsGrad.shape != rhsShape {
+                rhsGrad = rhsGrad.unbroadcasted(toShape: rhsShapeTensor)
+            }
+            return (lhsGrad, rhsGrad)
+        })
+    }
+}
+
+//===-------------------------------------------------------------------------------------------===//
+// Differentiable
+//===-------------------------------------------------------------------------------------------===//
+
+extension Tensor: Differentiable where Scalar: TensorFlowFloatingPoint {
+    public typealias TangentVector = Tensor
+    public typealias CotangentVector = Tensor
+    public typealias AllDifferentiableVariables = Tensor
+
+    @inlinable
+    public func tangentVector(
+        from cotangent: CotangentVector
+    ) -> TangentVector {
+        return cotangent
+    }
+}
diff --git a/Sources/DeepLearning/Core/TensorGroup.swift b/Sources/DeepLearning/Core/TensorGroup.swift
new file mode 100644
index 000000000..aae548d99
--- /dev/null
+++ b/Sources/DeepLearning/Core/TensorGroup.swift
@@ -0,0 +1,102 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+import TensorFlowCore
+
+extension Tensor: TensorGroup {
+    @inlinable
+    public static var _unknownShapeList: [TensorShape?] {
+        return [nil]
+    }
+
+    @inlinable
+    public static var _typeList: [TensorDataType] {
+        return [Scalar.tensorFlowDataType]
+    }
+
+    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
+        address!.initialize(to: handle._cTensorHandle)
+    }
+
+    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
+        self.init(handle: TensorHandle(_owning: tensorHandles!.pointee))
+    }
+}
+
+extension _TensorElementLiteral: TensorGroup {
+    @inlinable
+    public static var _unknownShapeList: [TensorShape?] {
+        return [nil]
+    }
+
+    @inlinable
+    public static var _typeList: [TensorDataType] {
+        return [Scalar.tensorFlowDataType]
+    }
+
+    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
+        address!.initialize(to: handle._cTensorHandle)
+    }
+
+    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
+        self.init(handle: TensorHandle(_owning: tensorHandles!.pointee))
+    }
+}
+
+extension StringTensor: TensorGroup {
+    @inlinable
+    public static var _unknownShapeList: [TensorShape?] {
+        return [nil]
+    }
+
+    @inlinable
+    public static var _typeList: [TensorDataType] {
+        return [String.tensorFlowDataType]
+    }
+
+    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
+        address!.initialize(to: handle._cTensorHandle)
+    }
+
+    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
+        self.init(handle: TensorHandle(_owning: tensorHandles!.pointee))
+    }
+}
+
+extension Array: TensorArrayProtocol where Element: TensorGroup {
+    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
+        var ptr = address
+        for elem in self {
+            elem._unpackTensorHandles(into: ptr)
+            ptr = ptr!.advanced(by: Int(elem._tensorHandleCount))
+        }
+    }
+
+    public var _tensorHandleCount: Int32 {
+        return Element._tensorHandleCount * Int32(count)
+    }
+
+    public var _typeList: [TensorDataType] {
+        return Array<TensorDataType>([[TensorDataType]](
+            repeating: Element._typeList,
+            count: Int(Element._tensorHandleCount)).joined())
+    }
+
+    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?, count: Int) {
+        let size = count / Int(Element._tensorHandleCount)
+        self = Array((0..<size).map { Element.init(
+            _owning: tensorHandles?.advanced(by: $0 * Int(Element._tensorHandleCount)))
+        })
+    }
+}
diff --git a/Sources/DeepLearning/Core/TensorHandle.swift b/Sources/DeepLearning/Core/TensorHandle.swift
new file mode 100644
index 000000000..efa91e2b3
--- /dev/null
+++ b/Sources/DeepLearning/Core/TensorHandle.swift
@@ -0,0 +1,26 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+internal extension TensorHandle {
+    /// Create a `ShapedArray` with contents of the underlying `TensorHandle`. If
+    /// the `TensorHandle` is on the accelerator, it will be copied to the host.
+    /// - Returns: A `ShapedArray`.
+    @usableFromInline
+    @inline(never)
+    func makeHostCopy() -> ShapedArray<Scalar> {
+        internalConsistencyCheck(isConcrete)
+        debugLog("Calling makeHostCopy() with c handle \(_cTensorHandle)")
+        return ShapedArray(cTensorHandle: _cTensorHandle)
+    }
+}
diff --git a/Sources/DeepLearning/Core/Utilities.swift b/Sources/DeepLearning/Core/Utilities.swift
new file mode 100644
index 000000000..d595b4645
--- /dev/null
+++ b/Sources/DeepLearning/Core/Utilities.swift
@@ -0,0 +1,70 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+import Darwin
+#else
+import Glibc
+#endif
+
+@_exported import TensorFlowCore
+
+//===----------------------------------------------------------------------===//
+// Unit test utilities
+//===----------------------------------------------------------------------===//
+// TODO: Move this section to a unit-test only Swift module, once the google
+// internal lit based test infra can handle importing additional Swift modules.
+
+/// This is a generic host-only op that hides the details of its impl in the SIL
+/// code. This makes reading/writing SIL based compiler unit tests simple.
+@inline(never)
+public func _hostOp<T>(_ x: T) {
+  print(x)
+}
+
+@inline(never)
+public func _hostOp<Scalar>(_ x: Tensor<Scalar>) {
+  print(x)
+}
+
+@inline(never)
+public func _hostOp<Scalar : TensorFlowScalar>(_ x: TensorHandle<Scalar>) {
+  print(Tensor(handle: x))
+}
+
+/// Some TPU ops (e.g. infeed/outfeed) require tensor shape info, which the APIs
+/// below can provide.
+///
+/// TODO: Remove these helper APIs, when we have a better shape
+/// inference/propagation design.
+@inlinable @inline(__always)
+public func _scalarTensorWithShape<Scalar>(
+  _ x: Tensor<Scalar>
+) -> Tensor<Scalar> {
+  let ret: TensorHandle<Scalar> =
+    #tfop("Identity", x, T$dtype: Scalar.tensorFlowDataType,
+          __shapes: [TensorShape()])
+  return Tensor<Scalar>(handle: ret)
+}
+
+@inlinable @inline(__always)
+public func _addScalarTensorsWithShape<Scalar>(
+  _ x: Tensor<Scalar>,
+  _ y: Tensor<Scalar>
+) -> Tensor<Scalar> {
+  let ret: TensorHandle<Scalar> =
+    #tfop("Add", x, y, T$dtype: Scalar.tensorFlowDataType,
+          __shapes: [TensorShape()])
+  return Tensor<Scalar>(handle: ret)
+}
diff --git a/Sources/DeepLearning/Helpers.swift b/Sources/DeepLearning/Helpers.swift
index 1d56b0f76..bb5d133bb 100644
--- a/Sources/DeepLearning/Helpers.swift
+++ b/Sources/DeepLearning/Helpers.swift
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-@_exported import TensorFlowCore
-
 /// Returns a tensor with the same shape and scalars as the specified tensor.
 @inlinable
 @differentiable
diff --git a/Sources/DeepLearning/Layer.swift b/Sources/DeepLearning/Layer.swift
index add039fcb..31f151f5e 100644
--- a/Sources/DeepLearning/Layer.swift
+++ b/Sources/DeepLearning/Layer.swift
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 /// A neural network layer.
 ///
 /// Types that conform to `Layer` represent functions that map inputs to outputs. They may have an
@@ -1224,269 +1222,269 @@ public struct Reshape<Scalar: TensorFlowFloatingPoint>: Layer {
     }
 }
 
-/// An input to a recurrent neural network.
-public struct RNNCellInput<Input: Differentiable, State: Differentiable>: Differentiable {
-    /// The input at the current time step.
-    public var input: Input
-    /// The previous state.
-    public var state: State
-
-    @differentiable
-    public init(input: Input, state: State) {
-        self.input = input
-        self.state = state
-    }
-}
-
-/// An output to a recurrent neural network.
-public struct RNNCellOutput<Output: Differentiable, State: Differentiable>: Differentiable {
-    /// The output at the current time step.
-    public var output: Output
-    /// The current state.
-    public var state: State
-
-    @differentiable
-    public init(output: Output, state: State) {
-        self.output = output
-        self.state = state
-    }
-}
-
-/// A recurrent neural network cell.
-public protocol RNNCell: Layer where Input == RNNCellInput<TimeStepInput, State>,
-                                     Output == RNNCellOutput<TimeStepOutput, State> {
-    /// The input at a time step.
-    associatedtype TimeStepInput: Differentiable
-    /// The output at a time step.
-    associatedtype TimeStepOutput: Differentiable
-    /// The state that may be preserved across time steps.
-    associatedtype State: Differentiable
-    /// The zero state.
-    var zeroState: State { get }
-}
-
-public extension RNNCell {
-    /// Returns the new state obtained from applying the RNN cell to the input at the current time
-    /// step and the previous state.
-    ///
-    /// - Parameters:
-    ///   - timeStepInput: The input at the current time step.
-    ///   - previousState: The previous state of the RNN cell.
-    /// - Returns: The output.
-    @differentiable
-    func call(input: TimeStepInput, state: State) -> RNNCellOutput<TimeStepOutput, State> {
-        return self(RNNCellInput(input: input, state: state))
-    }
-}
-
-/// A Simple RNN Cell.
-public struct SimpleRNNCell<Scalar: TensorFlowFloatingPoint>: RNNCell, VectorNumeric {
-    public var weight: Tensor<Scalar>
-    public var bias: Tensor<Scalar>
-
-    @noDerivative public var stateShape: TensorShape {
-        return TensorShape([1, weight.shape[1]])
-    }
-
-    public var zeroState: Tensor<Scalar> {
-        return Tensor(zeros: stateShape)
-    }
-
-    public typealias State = Tensor<Scalar>
-    public typealias TimeStepInput = Tensor<Scalar>
-    public typealias TimeStepOutput = State
-    public typealias Input = RNNCellInput<TimeStepInput, State>
-    public typealias Output = RNNCellOutput<TimeStepOutput, State>
-
-    /// Creates a `SimpleRNNCell` with the specified input size and hidden state size.
-    ///
-    /// - Parameters:
-    ///   - inputSize: The number of features in 2-D input tensors.
-    ///   - hiddenSize: The number of features in 2-D hidden states.
-    ///   - seed: The random seed for initialization. The default value is random.
-    public init(inputSize: Int, hiddenSize: Int,
-                seed: (Int64, Int64) = (Int64.random(in: Int64.min..<Int64.max),
-                                        Int64.random(in: Int64.min..<Int64.max))) {
-        let concatenatedInputSize = inputSize + hiddenSize
-        self.weight = Tensor(glorotUniform: [concatenatedInputSize, hiddenSize],
-                             seed: seed)
-        self.bias = Tensor(zeros: [hiddenSize])
-    }
-
-    /// Returns the output obtained from applying the layer to the given input.
-    ///
-    /// - Parameters:
-    ///   - input: The input to the layer.
-    ///   - context: The contextual information for the layer application, e.g. the current learning
-    ///     phase.
-    /// - Returns: The hidden state.
-    @differentiable
-    public func call(_ input: Input) -> Output {
-        let concatenatedInput = input.input.concatenated(with: input.state, alongAxis: 1)
-        let newState = tanh(matmul(concatenatedInput, weight) + bias)
-        return Output(output: newState, state: newState)
-    }
-}
-
-/// An LSTM Cell.
-public struct LSTMCell<Scalar: TensorFlowFloatingPoint>: RNNCell, VectorNumeric {
-    public var inputWeight, updateWeight, forgetWeight, outputWeight: Tensor<Scalar>
-    public var inputBias, updateBias, forgetBias, outputBias: Tensor<Scalar>
-
-    @noDerivative public var stateShape: TensorShape {
-        return TensorShape([1, inputWeight.shape[1]])
-    }
-
-    public var zeroState: State {
-        return State(cell: Tensor(zeros: stateShape), hidden: Tensor(zeros: stateShape))
-    }
-
-    public typealias TimeStepInput = Tensor<Scalar>
-    public typealias TimeStepOutput = State
-    public typealias Input = RNNCellInput<TimeStepInput, State>
-    public typealias Output = RNNCellOutput<TimeStepOutput, State>
-
-    /// Creates a `LSTMCell` with the specified input size and hidden state size.
-    ///
-    /// - Parameters:
-    ///   - inputSize: The number of features in 2-D input tensors.
-    ///   - hiddenSize: The number of features in 2-D hidden states.
-    public init(inputSize: Int, hiddenSize: Int,
-                seed: (Int64, Int64) = (Int64.random(in: Int64.min..<Int64.max),
-                                        Int64.random(in: Int64.min..<Int64.max))) {
-        let concatenatedInputSize = inputSize + hiddenSize
-        let gateWeightShape = TensorShape([concatenatedInputSize, hiddenSize])
-        let gateBiasShape = TensorShape([hiddenSize])
-        self.inputWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
-        self.inputBias = Tensor(zeros: gateBiasShape)
-        self.updateWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
-        self.updateBias = Tensor(zeros: gateBiasShape)
-        self.forgetWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
-        self.forgetBias = Tensor(ones: gateBiasShape)
-        self.outputWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
-        self.outputBias = Tensor(zeros: gateBiasShape)
-    }
-
-    public struct State: Differentiable {
-        public var cell: Tensor<Scalar>
-        public var hidden: Tensor<Scalar>
-
-        @differentiable
-        public init(cell: Tensor<Scalar>, hidden: Tensor<Scalar>) {
-            self.cell = cell
-            self.hidden = hidden
-        }
-    }
-
-    /// Returns the output obtained from applying the layer to the given input.
-    ///
-    /// - Parameters:
-    ///   - input: The input to the layer.
-    ///   - context: The contextual information for the layer application, e.g. the current learning
-    ///     phase.
-    /// - Returns: The hidden state.
-    @differentiable
-    public func call(_ input: Input) -> Output {
-        let gateInput = input.input.concatenated(with: input.state.hidden, alongAxis: 1)
-
-        let inputGate = sigmoid(matmul(gateInput, inputWeight) + inputBias)
-        let updateGate = tanh(matmul(gateInput, updateWeight) + updateBias)
-        let forgetGate = sigmoid(matmul(gateInput, forgetWeight) + forgetBias)
-        let outputGate = sigmoid(matmul(gateInput, outputWeight) + outputBias)
-
-        let newCellState = input.state.cell * forgetGate + inputGate * updateGate
-        let newHiddenState = tanh(newCellState) * outputGate
-
-        let newState = State(cell: newCellState, hidden: newHiddenState)
-
-        return Output(output: newState, state: newState)
-    }
-}
-
-public struct RNN<Cell: RNNCell>: Layer {
-    public typealias Input = [Cell.TimeStepInput]
-    public typealias Output = [Cell.TimeStepOutput]
-
-    public var cell: Cell
+// /// An input to a recurrent neural network.
+// public struct RNNCellInput<Input: Differentiable, State: Differentiable>: Differentiable {
+//     /// The input at the current time step.
+//     public var input: Input
+//     /// The previous state.
+//     public var state: State
+
+//     @differentiable
+//     public init(input: Input, state: State) {
+//         self.input = input
+//         self.state = state
+//     }
+// }
+
+// /// An output to a recurrent neural network.
+// public struct RNNCellOutput<Output: Differentiable, State: Differentiable>: Differentiable {
+//     /// The output at the current time step.
+//     public var output: Output
+//     /// The current state.
+//     public var state: State
+
+//     @differentiable
+//     public init(output: Output, state: State) {
+//         self.output = output
+//         self.state = state
+//     }
+// }
+
+// /// A recurrent neural network cell.
+// public protocol RNNCell: Layer where Input == RNNCellInput<TimeStepInput, State>,
+//                                      Output == RNNCellOutput<TimeStepOutput, State> {
+//     /// The input at a time step.
+//     associatedtype TimeStepInput: Differentiable
+//     /// The output at a time step.
+//     associatedtype TimeStepOutput: Differentiable
+//     /// The state that may be preserved across time steps.
+//     associatedtype State: Differentiable
+//     /// The zero state.
+//     var zeroState: State { get }
+// }
+
+// public extension RNNCell {
+//     /// Returns the new state obtained from applying the RNN cell to the input at the current time
+//     /// step and the previous state.
+//     ///
+//     /// - Parameters:
+//     ///   - timeStepInput: The input at the current time step.
+//     ///   - previousState: The previous state of the RNN cell.
+//     /// - Returns: The output.
+//     @differentiable
+//     func call(input: TimeStepInput, state: State) -> RNNCellOutput<TimeStepOutput, State> {
+//         return self(RNNCellInput(input: input, state: state))
+//     }
+// }
+
+// /// A Simple RNN Cell.
+// public struct SimpleRNNCell<Scalar: TensorFlowFloatingPoint>: RNNCell, VectorNumeric {
+//     public var weight: Tensor<Scalar>
+//     public var bias: Tensor<Scalar>
+
+//     @noDerivative public var stateShape: TensorShape {
+//         return TensorShape([1, weight.shape[1]])
+//     }
+
+//     public var zeroState: Tensor<Scalar> {
+//         return Tensor(zeros: stateShape)
+//     }
+
+//     public typealias State = Tensor<Scalar>
+//     public typealias TimeStepInput = Tensor<Scalar>
+//     public typealias TimeStepOutput = State
+//     public typealias Input = RNNCellInput<TimeStepInput, State>
+//     public typealias Output = RNNCellOutput<TimeStepOutput, State>
+
+//     /// Creates a `SimpleRNNCell` with the specified input size and hidden state size.
+//     ///
+//     /// - Parameters:
+//     ///   - inputSize: The number of features in 2-D input tensors.
+//     ///   - hiddenSize: The number of features in 2-D hidden states.
+//     ///   - seed: The random seed for initialization. The default value is random.
+//     public init(inputSize: Int, hiddenSize: Int,
+//                 seed: (Int64, Int64) = (Int64.random(in: Int64.min..<Int64.max),
+//                                         Int64.random(in: Int64.min..<Int64.max))) {
+//         let concatenatedInputSize = inputSize + hiddenSize
+//         self.weight = Tensor(glorotUniform: [concatenatedInputSize, hiddenSize],
+//                              seed: seed)
+//         self.bias = Tensor(zeros: [hiddenSize])
+//     }
+
+//     /// Returns the output obtained from applying the layer to the given input.
+//     ///
+//     /// - Parameters:
+//     ///   - input: The input to the layer.
+//     ///   - context: The contextual information for the layer application, e.g. the current learning
+//     ///     phase.
+//     /// - Returns: The hidden state.
+//     @differentiable
+//     public func call(_ input: Input) -> Output {
+//         let concatenatedInput = input.input.concatenated(with: input.state, alongAxis: 1)
+//         let newState = tanh(matmul(concatenatedInput, weight) + bias)
+//         return Output(output: newState, state: newState)
+//     }
+// }
+
+// /// An LSTM Cell.
+// public struct LSTMCell<Scalar: TensorFlowFloatingPoint>: RNNCell, VectorNumeric {
+//     public var inputWeight, updateWeight, forgetWeight, outputWeight: Tensor<Scalar>
+//     public var inputBias, updateBias, forgetBias, outputBias: Tensor<Scalar>
+
+//     @noDerivative public var stateShape: TensorShape {
+//         return TensorShape([1, inputWeight.shape[1]])
+//     }
+
+//     public var zeroState: State {
+//         return State(cell: Tensor(zeros: stateShape), hidden: Tensor(zeros: stateShape))
+//     }
+
+//     public typealias TimeStepInput = Tensor<Scalar>
+//     public typealias TimeStepOutput = State
+//     public typealias Input = RNNCellInput<TimeStepInput, State>
+//     public typealias Output = RNNCellOutput<TimeStepOutput, State>
+
+//     /// Creates a `LSTMCell` with the specified input size and hidden state size.
+//     ///
+//     /// - Parameters:
+//     ///   - inputSize: The number of features in 2-D input tensors.
+//     ///   - hiddenSize: The number of features in 2-D hidden states.
+//     public init(inputSize: Int, hiddenSize: Int,
+//                 seed: (Int64, Int64) = (Int64.random(in: Int64.min..<Int64.max),
+//                                         Int64.random(in: Int64.min..<Int64.max))) {
+//         let concatenatedInputSize = inputSize + hiddenSize
+//         let gateWeightShape = TensorShape([concatenatedInputSize, hiddenSize])
+//         let gateBiasShape = TensorShape([hiddenSize])
+//         self.inputWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
+//         self.inputBias = Tensor(zeros: gateBiasShape)
+//         self.updateWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
+//         self.updateBias = Tensor(zeros: gateBiasShape)
+//         self.forgetWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
+//         self.forgetBias = Tensor(ones: gateBiasShape)
+//         self.outputWeight = Tensor(glorotUniform: gateWeightShape, seed: seed)
+//         self.outputBias = Tensor(zeros: gateBiasShape)
+//     }
+
+//     public struct State: Differentiable {
+//         public var cell: Tensor<Scalar>
+//         public var hidden: Tensor<Scalar>
+
+//         @differentiable
+//         public init(cell: Tensor<Scalar>, hidden: Tensor<Scalar>) {
+//             self.cell = cell
+//             self.hidden = hidden
+//         }
+//     }
+
+//     /// Returns the output obtained from applying the layer to the given input.
+//     ///
+//     /// - Parameters:
+//     ///   - input: The input to the layer.
+//     ///   - context: The contextual information for the layer application, e.g. the current learning
+//     ///     phase.
+//     /// - Returns: The hidden state.
+//     @differentiable
+//     public func call(_ input: Input) -> Output {
+//         let gateInput = input.input.concatenated(with: input.state.hidden, alongAxis: 1)
+
+//         let inputGate = sigmoid(matmul(gateInput, inputWeight) + inputBias)
+//         let updateGate = tanh(matmul(gateInput, updateWeight) + updateBias)
+//         let forgetGate = sigmoid(matmul(gateInput, forgetWeight) + forgetBias)
+//         let outputGate = sigmoid(matmul(gateInput, outputWeight) + outputBias)
+
+//         let newCellState = input.state.cell * forgetGate + inputGate * updateGate
+//         let newHiddenState = tanh(newCellState) * outputGate
+
+//         let newState = State(cell: newCellState, hidden: newHiddenState)
+
+//         return Output(output: newState, state: newState)
+//     }
+// }
+
+// public struct RNN<Cell: RNNCell>: Layer {
+//     public typealias Input = [Cell.TimeStepInput]
+//     public typealias Output = [Cell.TimeStepOutput]
+
+//     public var cell: Cell
     
-    public init(_ cell: @autoclosure () -> Cell) {
-        self.cell = cell()
-    }
-
-    @differentiable(wrt: (self, input), vjp: _vjpCall(_:initialState:))
-    public func call(_ input: [Cell.TimeStepInput],
-                     initialState: Cell.State) -> [Cell.TimeStepOutput] {
-        var currentHiddenState = initialState
-        var timeStepOutputs: [Cell.TimeStepOutput] = []
-        for timestep in input {
-            let output = cell(input: timestep, state: currentHiddenState)
-            currentHiddenState = output.state
-            timeStepOutputs.append(output.output)
-        }
-        return timeStepOutputs
-    }
-
-    @usableFromInline
-    internal func _vjpCall(
-        _ inputs: [Cell.TimeStepInput], initialState: Cell.State
-    ) -> ([Cell.TimeStepOutput],
-          (Array<Cell.TimeStepOutput>.CotangentVector)
-              -> (CotangentVector, Array<Cell.TimeStepInput>.CotangentVector)) {
-        let timeStepCount = inputs.count
-        var currentHiddenState = cell.zeroState
-        var timeStepOutputs: [Cell.TimeStepOutput] = []
-        timeStepOutputs.reserveCapacity(timeStepCount)
-        var backpropagators: [Cell.Backpropagator] = []
-        backpropagators.reserveCapacity(timeStepCount)
-        for timestep in inputs {
-            let (output, backpropagator) =
-                cell.appliedForBackpropagation(to: .init(input: timestep,
-                                                         state: currentHiddenState))
-            currentHiddenState = output.state
-            timeStepOutputs.append(output.output)
-            backpropagators.append(backpropagator)
-        }
-        return (timeStepOutputs, { 𝛁outputs in
-            precondition(𝛁outputs.base.count == timeStepCount,
-                         "The number of output gradients must equal the number of time steps")
-            var 𝛁cell = Cell.CotangentVector.zero
-            var 𝛁state = Cell.State.CotangentVector.zero
-            var reversed𝛁inputs: [Cell.TimeStepInput.CotangentVector] = []
-            reversed𝛁inputs.reserveCapacity(timeStepCount)
-            for (𝛁output, backpropagator) in zip(𝛁outputs.base, backpropagators).reversed() {
-                let (new𝛁cell, 𝛁input) = backpropagator(.init(output: 𝛁output, state: 𝛁state))
-                𝛁cell = new𝛁cell
-                𝛁state = 𝛁input.state
-                reversed𝛁inputs.append(𝛁input.input)
-            }
-            return (.init(cell: 𝛁cell), .init(Array(reversed𝛁inputs.reversed())))
-        })
-    }
-
-    @differentiable(wrt: (self, inputs))
-    public func call(_ inputs: [Cell.TimeStepInput]) -> [Cell.TimeStepOutput] {
-        return self(inputs, initialState: cell.zeroState.withoutDerivative())
-    }
-
-    /* TODO: Uncomment once control flow and differentiation through force unwrapping is supported.
-    @differentiable(wrt: (self, inputs))
-    public func lastOutput(from inputs: [Cell.TimeStepInput],
-                           initialState: Cell.State) -> Cell.TimeStepOutput {
-        precondition(!inputs.isEmpty, "inputs cannot be empty")
-        return self(inputs, initialState: initialState).last!
-    }
-
-    @differentiable(wrt: (self, inputs))
-    public func lastOutput(from inputs: [Cell.TimeStepInput]) -> Cell.TimeStepOutput {
-        precondition(!inputs.isEmpty, "inputs cannot be empty")
-        return self(inputs, initialState: cell.zeroState).last!
-    }
-    */
-}
-
-extension RNN: Equatable where Cell: Equatable {}
-extension RNN: AdditiveArithmetic where Cell: AdditiveArithmetic {}
-extension RNN: VectorNumeric where Cell: VectorNumeric {}
-
-public typealias SimpleRNN<Scalar: TensorFlowFloatingPoint> = RNN<SimpleRNNCell<Scalar>>
-public typealias LSTM<Scalar: TensorFlowFloatingPoint> = RNN<LSTMCell<Scalar>>
+//     public init(_ cell: @autoclosure () -> Cell) {
+//         self.cell = cell()
+//     }
+
+//     @differentiable(wrt: (self, input), vjp: _vjpCall(_:initialState:))
+//     public func call(_ input: [Cell.TimeStepInput],
+//                      initialState: Cell.State) -> [Cell.TimeStepOutput] {
+//         var currentHiddenState = initialState
+//         var timeStepOutputs: [Cell.TimeStepOutput] = []
+//         for timestep in input {
+//             let output = cell(input: timestep, state: currentHiddenState)
+//             currentHiddenState = output.state
+//             timeStepOutputs.append(output.output)
+//         }
+//         return timeStepOutputs
+//     }
+
+//     @usableFromInline
+//     internal func _vjpCall(
+//         _ inputs: [Cell.TimeStepInput], initialState: Cell.State
+//     ) -> ([Cell.TimeStepOutput],
+//           (Array<Cell.TimeStepOutput>.CotangentVector)
+//               -> (CotangentVector, Array<Cell.TimeStepInput>.CotangentVector)) {
+//         let timeStepCount = inputs.count
+//         var currentHiddenState = cell.zeroState
+//         var timeStepOutputs: [Cell.TimeStepOutput] = []
+//         timeStepOutputs.reserveCapacity(timeStepCount)
+//         var backpropagators: [Cell.Backpropagator] = []
+//         backpropagators.reserveCapacity(timeStepCount)
+//         for timestep in inputs {
+//             let (output, backpropagator) =
+//                 cell.appliedForBackpropagation(to: .init(input: timestep,
+//                                                          state: currentHiddenState))
+//             currentHiddenState = output.state
+//             timeStepOutputs.append(output.output)
+//             backpropagators.append(backpropagator)
+//         }
+//         return (timeStepOutputs, { 𝛁outputs in
+//             precondition(𝛁outputs.base.count == timeStepCount,
+//                          "The number of output gradients must equal the number of time steps")
+//             var 𝛁cell = Cell.CotangentVector.zero
+//             var 𝛁state = Cell.State.CotangentVector.zero
+//             var reversed𝛁inputs: [Cell.TimeStepInput.CotangentVector] = []
+//             reversed𝛁inputs.reserveCapacity(timeStepCount)
+//             for (𝛁output, backpropagator) in zip(𝛁outputs.base, backpropagators).reversed() {
+//                 let (new𝛁cell, 𝛁input) = backpropagator(.init(output: 𝛁output, state: 𝛁state))
+//                 𝛁cell = new𝛁cell
+//                 𝛁state = 𝛁input.state
+//                 reversed𝛁inputs.append(𝛁input.input)
+//             }
+//             return (.init(cell: 𝛁cell), .init(Array(reversed𝛁inputs.reversed())))
+//         })
+//     }
+
+//     @differentiable(wrt: (self, inputs))
+//     public func call(_ inputs: [Cell.TimeStepInput]) -> [Cell.TimeStepOutput] {
+//         return self(inputs, initialState: cell.zeroState.withoutDerivative())
+//     }
+
+//     /* TODO: Uncomment once control flow and differentiation through force unwrapping is supported.
+//     @differentiable(wrt: (self, inputs))
+//     public func lastOutput(from inputs: [Cell.TimeStepInput],
+//                            initialState: Cell.State) -> Cell.TimeStepOutput {
+//         precondition(!inputs.isEmpty, "inputs cannot be empty")
+//         return self(inputs, initialState: initialState).last!
+//     }
+
+//     @differentiable(wrt: (self, inputs))
+//     public func lastOutput(from inputs: [Cell.TimeStepInput]) -> Cell.TimeStepOutput {
+//         precondition(!inputs.isEmpty, "inputs cannot be empty")
+//         return self(inputs, initialState: cell.zeroState).last!
+//     }
+//     */
+// }
+
+// extension RNN: Equatable where Cell: Equatable {}
+// extension RNN: AdditiveArithmetic where Cell: AdditiveArithmetic {}
+// extension RNN: VectorNumeric where Cell: VectorNumeric {}
+
+// public typealias SimpleRNN<Scalar: TensorFlowFloatingPoint> = RNN<SimpleRNNCell<Scalar>>
+// public typealias LSTM<Scalar: TensorFlowFloatingPoint> = RNN<LSTMCell<Scalar>>
diff --git a/Sources/DeepLearning/Operators/Basic.swift b/Sources/DeepLearning/Operators/Basic.swift
index 34ffaa75f..e1fada457 100644
--- a/Sources/DeepLearning/Operators/Basic.swift
+++ b/Sources/DeepLearning/Operators/Basic.swift
@@ -14,6 +14,8 @@
 
 import TensorFlowCore
 
+infix operator .!=: ComparisonPrecedence
+
 //===------------------------------------------------------------------------------------------===//
 // Shape Transformations
 //===------------------------------------------------------------------------------------------===//
@@ -336,8 +338,8 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
         with other: Tensor,
         alongAxis axis: Int
     ) -> (Tensor, (Tensor) -> (Tensor, Tensor)) {
-        let idx = axis < 0 ? axis + rank: axis
-        let splits = Tensor<Int32>([shapeTensor[idx], other.shapeTensor[idx]])
+        let posAxis = axis < 0 ? axis + rank: axis
+        let splits = Tensor<Int32>([shapeTensor[posAxis], other.shapeTensor[posAxis]])
         return (concatenated(with: other, alongAxis: axis), { result in
             let gradients = result.split(sizes: splits, alongAxis: axis)
             return (gradients[0], gradients[1])
@@ -378,22 +380,22 @@ public extension Tensor {
 
 public extension Tensor where Scalar: Numeric {
     @inlinable
-    func unbroadcast(toShape otherShape: Tensor<Int32>) -> Tensor {
-        let rankDiff: Tensor<Int32> = (rankTensor - otherShape.scalarCountTensor).rankLifted()
-        let ones: Tensor<Int32> = Raw.fill(dims: rankDiff, value: Tensor<Int32>(1))
+    func unbroadcasted(toShape otherShape: Tensor<Int32>) -> Tensor {
+        let rankDiff = (rankTensor - otherShape.scalarCountTensor).rankLifted()
+        let ones = Raw.fill(dims: rankDiff, value: Tensor<Int32>(1))
         let paddedShape = Tensor<Int32>(concatenating: [ones, otherShape], alongAxis: 0)
         let broadcastIndices = Tensor<Int32>(Raw.where_(paddedShape .!= shapeTensor))
         return sum(squeezingAxes: broadcastIndices).reshaped(toShape: otherShape)
     }
 
     @inlinable
-    func unbroadcast<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor {
-        return unbroadcast(toShape: other.shapeTensor)
+    func unbroadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor {
+        return unbroadcasted(toShape: other.shapeTensor)
     }
 
     @inlinable
-    func unbroadcast(to shape: TensorShape) -> Tensor {
-        return unbroadcast(toShape: Tensor<Int32>(shape.dimensions.map(Int32.init)))
+    func unbroadcasted(to shape: TensorShape) -> Tensor {
+        return unbroadcasted(toShape: Tensor<Int32>(shape.dimensions.map(Int32.init)))
     }
 }
 
diff --git a/Sources/DeepLearning/Operators/Dataset.swift b/Sources/DeepLearning/Operators/Dataset.swift
index 31d87c588..d4488d1e9 100644
--- a/Sources/DeepLearning/Operators/Dataset.swift
+++ b/Sources/DeepLearning/Operators/Dataset.swift
@@ -21,29 +21,26 @@ import TensorFlowCore
 
 /// Returns the local seeds an operation should use given an op-specific seed.
 ///
-/// Given operation-specific seed, `seed`, this helper function returns two
-/// seeds derived from graph-level and op-level seeds. Many random operations
-/// internally use the two seeds to allow user to change the seed globally for a
-/// graph, or for only specific operations.
+/// Given operation-specific seed, `seed`, this helper function returns two seeds derived from 
+/// graph-level and op-level seeds. Many random operations internally use the two seeds to allow 
+/// user to change the seed globally for a graph, or for only specific operations.
 ///
 /// - Note: See TensorFlow's `python.framework.random_seed.get_seed`.
 ///
-// TODO: There's no support for TF's "global seed" yet, so we always use the
-// default graph seed as the first seed. Need to investigate the best way to
-// model TF's "global seed".
+// TODO: There's no support for TF's "global seed" yet, so we always use the default graph seed as 
+// the first seed. Need to investigate the best way to model TF's "global seed".
 @usableFromInline @inline(__always)
 func _tensorSeeds(_ seed: Tensor<Int64>) -> (Tensor<Int64>, Tensor<Int64>) {
     return (Tensor(_defaultGraphSeed), seed)
 }
 
-//===----------------------------------------------------------------------===//
-// Single value dataset
-//===----------------------------------------------------------------------===//
+//===------------------------------------------------------------------------------------------===//
+// Single Value Dataset
+//===------------------------------------------------------------------------------------------===//
 
 /// Represents a potentially large set of elements.
 ///
-/// A `Dataset` can be used to represent an input pipeline as a collection of
-/// element tensors.
+/// A `Dataset` can be used to represent an input pipeline as a collection of element tensors.
 @_fixed_layout
 public struct Dataset<Element: TensorGroup> {
     public let _handle: VariantHandle
@@ -92,8 +89,8 @@ extension Dataset: Sequence {
 }
 
 public extension Dataset {
-    // Note that this Dataset API implementation uses an experimental tracing
-    // feature, which is not robust and does not have great diagnostics yet.
+    // Note that this Dataset API implementation uses an experimental tracing feature, which is not 
+    // robust and does not have great diagnostics yet.
     @inlinable @inline(__always)
     func map<ResultElement: TensorGroup>(
         _ transform: (Element) -> ResultElement
@@ -179,8 +176,7 @@ public struct DatasetIterator<Element: TensorGroup> {
 }
 
 extension DatasetIterator: IteratorProtocol {
-    /// Advances to the next element and returns it, or `nil` if no next element
-    /// exists.
+    /// Advances to the next element and returns it, or `nil` if no next element exists.
     @inlinable @inline(__always)
     public mutating func next() -> Element? {
         let optional = Raw.iteratorGetNextAsOptional(
@@ -196,8 +192,8 @@ extension DatasetIterator: IteratorProtocol {
     }
 }
 
-/// A 2-tuple-like struct that conforms to TensorGroup that represents a tuple 
-/// of 2 types conforming to TensorGroup.
+/// A 2-tuple-like struct that conforms to TensorGroup that represents a tuple of 2 types conforming 
+/// to `TensorGroup`.
 @_fixed_layout
 public struct Zip2TensorGroup<T: TensorGroup, U: TensorGroup>: TensorGroup {
     public var first: T
diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/DeepLearning/Operators/Math.swift
index 0d3250d29..0cd7e8c9b 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/DeepLearning/Operators/Math.swift
@@ -37,8 +37,20 @@ extension Tensor: VectorNumeric where Scalar: Numeric {
 internal extension Tensor where Scalar: TensorFlowFloatingPoint {
     @inlinable
     static func _vjpMultiply(lhs: Tensor, rhs: Tensor) -> (Tensor, (Tensor) -> (Tensor, Tensor)) {
-        return (lhs * rhs, { [lhsShape = lhs.shapeTensor, rhsShape = rhs.shapeTensor] v in
-            ((rhs * v).unbroadcast(toShape: lhsShape), (lhs * v).unbroadcast(toShape: rhsShape))
+        return (lhs * rhs, { [
+            lhsShape = lhs.shape,
+            rhsShape = rhs.shape,
+            lhsShapeTensor = lhs.shapeTensor,
+            rhsShapeTensor = rhs.shapeTensor] v in
+            var lhsGrad = rhs * v
+            var rhsGrad = lhs * v
+            if lhsGrad.shape != lhsShape {
+                lhsGrad = lhsGrad.unbroadcasted(toShape: lhsShapeTensor)
+            }
+            if rhsGrad.shape != rhsShape {
+                rhsGrad = rhsGrad.unbroadcasted(toShape: rhsShapeTensor)
+            }
+            return (lhsGrad, rhsGrad)
         })
     }
 }
@@ -238,9 +250,20 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
 
     @inlinable
     static func _vjpDivide(lhs: Tensor, rhs: Tensor) -> (Tensor, (Tensor) -> (Tensor, Tensor)) {
-        return (lhs / rhs, { [lhsShape = lhs.shapeTensor, rhsShape = rhs.shapeTensor] v in
-            ((v / rhs).unbroadcast(toShape: lhsShape),
-             ((-lhs) / rhs.squared() * v).unbroadcast(toShape: rhsShape))
+        return (lhs / rhs, { [
+            lhsShape = lhs.shape,
+            rhsShape = rhs.shape,
+            lhsShapeTensor = lhs.shapeTensor,
+            rhsShapeTensor = rhs.shapeTensor] v in
+            var lhsGrad = v / rhs
+            var rhsGrad = (-lhs) / rhs.squared() * v
+            if lhsGrad.shape != lhsShape {
+                lhsGrad = lhsGrad.unbroadcasted(toShape: lhsShapeTensor)
+            }
+            if rhsGrad.shape != rhsShape {
+                rhsGrad = rhsGrad.unbroadcasted(toShape: rhsShapeTensor)
+            }
+            return (lhsGrad, rhsGrad)
         })
     }
 
@@ -674,8 +697,16 @@ internal func _vjpPow<T: TensorFlowFloatingPoint>(
 ) -> (Tensor<T>, (Tensor<T>) -> (Tensor<T>, Tensor<T>)) {
     let value = pow(x, y)
     return (value, { v in
-        ((v * y * pow(x, y-1)).unbroadcast(like: x),
-        (v * log(x) * value).unbroadcast(like: y))
+        let safeX = x.replacing(with: Tensor<T>(onesLike: x), where: x .<= 0)
+        var gradX = v * y * pow(x, y - 1)
+        var gradY = value * v * log(safeX)
+        if gradX.shape != x.shape {
+            gradX = gradX.unbroadcasted(like: x)
+        }
+        if gradY.shape != y.shape {
+            gradY = gradY.unbroadcasted(like: y)
+        }
+        return (gradX, gradY)
     })
 }
 
@@ -706,7 +737,7 @@ internal func _vjpMax<T: TensorFlowFloatingPoint>(
     _ x: Tensor<T>, _ y: Tensor<T>
 ) -> (Tensor<T>, (Tensor<T>) -> (Tensor<T>, Tensor<T>)) {
     let value = max(x, y)
-    return (value, { v in _vjpMinMaxHelper(x, y, originalValue: value, vector: v) })
+    return (value, { v in _vjpMinMaxHelper(x, y, originalValue: value, seed: v) })
 }
 
 /// Computes the element-wise maximum of the scalar and the tensor, broadcasting the scalar.
@@ -736,7 +767,7 @@ internal func _vjpMin<T: TensorFlowFloatingPoint>(
     _ x: Tensor<T>, _ y: Tensor<T>
 ) -> (Tensor<T>, (Tensor<T>) -> (Tensor<T>, Tensor<T>)) {
     let value = min(x, y)
-    return (value, { v in _vjpMinMaxHelper(x, y, originalValue: value, vector: v) })
+    return (value, { v in _vjpMinMaxHelper(x, y, originalValue: value, seed: v) })
 }
 
 /// Computes the element-wise minimum of the scalar and the tensor, broadcasting the scalar.
@@ -758,12 +789,18 @@ internal func _vjpMinMaxHelper<T: TensorFlowFloatingPoint>(
     _ x: Tensor<T>,
     _ y: Tensor<T>,
     originalValue: Tensor<T>,
-    vector: Tensor<T>
+    seed: Tensor<T>
 ) -> (Tensor<T>, Tensor<T>) {
-    let denom = 1 + Tensor<T>(x .== y)
-    let dfdx = vector * Tensor<T>(x .== originalValue) / denom
-    let dfdy = vector * Tensor<T>(y .== originalValue) / denom
-    return (dfdx.unbroadcast(like: x), dfdy.unbroadcast(like: y))
+    let denominator = 1 + Tensor<T>(x .== y)
+    var gradX = seed * Tensor<T>(x .== originalValue) / denominator
+    var gradY = seed * Tensor<T>(y .== originalValue) / denominator
+    if gradX.shape != x.shape {
+        gradX = gradX.unbroadcasted(like: x)
+    }
+    if gradY.shape != y.shape {
+        gradY = gradY.unbroadcasted(like: y)
+    }
+    return (gradX, gradY)
 }
 
 //===------------------------------------------------------------------------------------------===//
diff --git a/Sources/DeepLearning/Optimizer.swift b/Sources/DeepLearning/Optimizer.swift
index bbd0b95a2..649cf46f1 100644
--- a/Sources/DeepLearning/Optimizer.swift
+++ b/Sources/DeepLearning/Optimizer.swift
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 /// A machine learning optimizer.
 ///
 /// Optimizers apply an optimization algorithm to update the differentiable variables of a machine
diff --git a/Sources/DeepLearning/Random.swift b/Sources/DeepLearning/Random.swift
index ea0783f1d..99906a8be 100644
--- a/Sources/DeepLearning/Random.swift
+++ b/Sources/DeepLearning/Random.swift
@@ -18,6 +18,8 @@ import Darwin
 import Glibc
 #endif
 
+import TensorFlowCore
+
 //===------------------------------------------------------------------------------------------===//
 // Random Number Generators
 //===------------------------------------------------------------------------------------------===//
diff --git a/Sources/DeepLearning/Tensor.swift b/Sources/DeepLearning/Tensor.swift
deleted file mode 100644
index c94354ff1..000000000
--- a/Sources/DeepLearning/Tensor.swift
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
-//
-// 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.
-
-import TensorFlowCore
-
-infix operator .==: ComparisonPrecedence
-
-//===------------------------------------------------------------------------------------------===//
-// Description and Visualization
-//===------------------------------------------------------------------------------------------===//
-
-// String conversion.
-extension Tensor: CustomStringConvertible {
-    /// A textual representation of the tensor.
-    ///
-    /// - Note: use `fullDescription` for a non-pretty-printed description showing all scalars.
-    public var description: String {
-        @_semantics("autodiff.nonvarying")
-        get {
-            return array.description
-        }
-    }
-}
-
-public extension Tensor {
-    /// A textual representation of the tensor. Returns a summarized description if `summarize` is
-    /// true and the element count exceeds twice the `edgeElementCount`.
-    ///
-    /// - Parameters:
-    ///   - lineWidth: The max line width for printing. Used to determine number of scalars to print
-    ///     per line.
-    ///   - edgeElementCount: The maximum number of elements to print before and after summarization
-    ///     via ellipses (`...`).
-    ///   - summarizing: If true, summarize description if element count exceeds twice
-    ///     `edgeElementCount`.
-    func description(
-        lineWidth: Int = 80,
-        edgeElementCount: Int = 3,
-        summarizing: Bool = false
-    ) -> String {
-        return array.description(
-            lineWidth: lineWidth,
-            edgeElementCount: edgeElementCount,
-            summarizing: summarizing)
-    }
-
-    /// A full, non-pretty-printed textual representation of the tensor, showing
-    /// all scalars.
-    var fullDescription: String {
-        @_semantics("autodiff.nonvarying")
-        get {
-            return array.fullDescription
-        }
-    }
-}
-
-// Xcode Playground display conversion.
-extension Tensor: CustomPlaygroundDisplayConvertible {
-    public var playgroundDescription: Any {
-        @_semantics("autodiff.nonvarying")
-        get {
-            return description
-        }
-    }
-}
-
-// Mirror representation, used by debugger/REPL.
-extension Tensor: CustomReflectable {
-    public var customMirror: Mirror {
-        @_semantics("autodiff.nonvarying")
-        get {
-            return Mirror(self, children: [], displayStyle: .struct)
-        }
-    }
-}
-
-//===------------------------------------------------------------------------------------------===//
-// Codable Conformance
-//===------------------------------------------------------------------------------------------===//
-
-extension Tensor: Codable where Scalar: Codable {
-    @inlinable
-    public func encode(to encoder: Encoder) throws {
-        var container = encoder.singleValueContainer()
-        try container.encode(array)
-    }
-
-    @inlinable
-    public init(from decoder: Decoder) throws {
-        let container = try decoder.singleValueContainer()
-        let array = try container.decode(ShapedArray<Scalar>.self)
-        self.init(array)
-    }
-}
diff --git a/Tests/DeepLearningTests/OperatorTests/BasicTests.swift b/Tests/DeepLearningTests/OperatorTests/BasicTests.swift
index b3afb3ba1..a0a4edbad 100644
--- a/Tests/DeepLearningTests/OperatorTests/BasicTests.swift
+++ b/Tests/DeepLearningTests/OperatorTests/BasicTests.swift
@@ -409,17 +409,17 @@ final class BasicOperatorTests: XCTestCase {
         XCTAssertEqual([1, 3, 1, 2, 1], result.shape)
     }
 
-    func testUnbroadcast1() {
+    func testUnbroadcasted1() {
         let x = Tensor<Float>(repeating: 1, shape: [2, 3, 4, 5])
         let y = Tensor<Float>(repeating: 1, shape: [4, 5])
-        let z = x.unbroadcast(like: y)
+        let z = x.unbroadcasted(like: y)
         XCTAssertEqual(ShapedArray<Float>(repeating: 6, shape: [4, 5]), z.array)
     }
 
-    func testUnbroadcast2() {
+    func testUnbroadcasted2() {
         let x = Tensor<Float>(repeating: 1, shape: [2, 3, 4, 5])
         let y = Tensor<Float>(repeating: 1, shape: [3, 1, 5])
-        let z = x.unbroadcast(like: y)
+        let z = x.unbroadcasted(like: y)
         XCTAssertEqual(ShapedArray<Float>(repeating: 8, shape: [3, 1, 5]), z.array)
     }
 
@@ -470,8 +470,8 @@ final class BasicOperatorTests: XCTestCase {
         ("testFlatten0D", testFlatten0D),
         ("testReshapeToScalar", testReshapeToScalar),
         ("testReshapeTensor", testReshapeTensor),
-        ("testUnbroadcast1", testUnbroadcast1),
-        ("testUnbroadcast2", testUnbroadcast2),
+        ("testUnbroadcasted1", testUnbroadcasted1),
+        ("testUnbroadcasted2", testUnbroadcasted2),
         ("testSliceUpdate", testSliceUpdate),
         ("testBroadcastTensor", testBroadcastTensor)
     ]

From 5e301a6ebd10d54c56ec1d756e21038ddb5f7ab0 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 28 Apr 2019 17:54:28 -0400
Subject: [PATCH 15/55] Removed the deprecated 'Tensor.selecting(_:_:)'
 function.

---
 Sources/DeepLearning/Operators/Math.swift | 20 --------------------
 1 file changed, 20 deletions(-)

diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/DeepLearning/Operators/Math.swift
index 0cd7e8c9b..075c79d92 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/DeepLearning/Operators/Math.swift
@@ -807,26 +807,6 @@ internal func _vjpMinMaxHelper<T: TensorFlowFloatingPoint>(
 // Selection Functions
 //===------------------------------------------------------------------------------------------===//
 
-public extension Tensor where Scalar == Bool {
-    /// Returns a new tensor containing elements from either `left` or `right`,
-    /// depending on the elements of `self`.
-    ///
-    /// `self` acts as a mask that chooses, based on the value at each scalar,
-    ///  whether the corresponding scalar in the output should be taken from
-    /// `left` (if `true`) or `right` (if `false`).
-    ///
-    /// - Precondition: `left` and `right` must have the same shape. If
-    ///   `left` and `right` are scalar, then `self` must also be scalar. If
-    ///   `left` and `right` have rank greater than or equal to 1, then `self`
-    ///   must be either have the same shape as `left` or be a 1-D `Tensor` such
-    ///   that `self.scalarCount == left[0]`.
-    @available(*, deprecated, message: "Use '.replacing(with:mask:)' instead")
-    @inlinable
-    func selecting<T>(_ left: Tensor<T>, _ right: Tensor<T>) -> Tensor<T> {
-        return left.replacing(with: right, where: self)
-    }
-}
-
 public extension Tensor {
     /// Replaces elements of this tensor with `other` in the lanes where `mask` is
     /// `true`.

From 4e0914e340d01674fa646cf2d8d2d13aa209562c Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Wed, 1 May 2019 21:37:41 -0400
Subject: [PATCH 16/55] Added support for 'Dataset.parallelMap'.

---
 Sources/DeepLearning/Operators/Dataset.swift | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/Sources/DeepLearning/Operators/Dataset.swift b/Sources/DeepLearning/Operators/Dataset.swift
index d4488d1e9..46ae73b5c 100644
--- a/Sources/DeepLearning/Operators/Dataset.swift
+++ b/Sources/DeepLearning/Operators/Dataset.swift
@@ -67,7 +67,6 @@ public extension Dataset {
     /// Creates a dataset from a batch of elements as a tensor.
     @inlinable @inline(__always)
     init(elements: Element) {
-        // A dataset creation op only runs on TF CPU.
         self.init(_handle: Raw.tensorSliceDataset(
             components: [elements],
             outputShapes: Element._unknownShapeList))
@@ -105,6 +104,23 @@ public extension Dataset {
             preserveCardinality: false))
     }
 
+    @inlinable @inline(__always)
+    func map<ResultElement : TensorGroup>(
+        parallelCallCount: Int,
+        _ transform: (Element) -> ResultElement
+    ) -> Dataset<ResultElement> {
+        return Dataset<ResultElement>(_handle: Raw.parallelMapDataset(
+            inputDataset: _handle,
+            otherArguments: Tensor<Int32>(0),
+            numParallelCalls: Tensor<Int32>(Int32(parallelCallCount)),
+            f: transform,
+            outputTypes: ResultElement._typeList,
+            outputShapes: ResultElement._unknownShapeList,
+            useInterOpParallelism: true,
+            sloppy: false,
+            preserveCardinality: false))
+    }
+
     @inlinable @inline(__always)
     func filter(
         _ isIncluded: (Element) -> Tensor<Bool>

From 5d277ca181461908cd2303690189aa471280de35 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Wed, 1 May 2019 21:38:16 -0400
Subject: [PATCH 17/55] Made the 'Tensor' subscript getter differentiable.

---
 Sources/DeepLearning/Operators/Basic.swift | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Sources/DeepLearning/Operators/Basic.swift b/Sources/DeepLearning/Operators/Basic.swift
index e1fada457..cfb0b4230 100644
--- a/Sources/DeepLearning/Operators/Basic.swift
+++ b/Sources/DeepLearning/Operators/Basic.swift
@@ -578,12 +578,12 @@ public extension PartialRangeThrough where Bound == Int {
 
 public extension Tensor {
     @_fixed_layout @usableFromInline
-    internal struct IndexPath {
+    internal struct IndexPath: Differentiable {
         @usableFromInline
-        let begin, end, strides: Tensor<Int32>
+        @noDerivative let begin, end, strides: Tensor<Int32>
 
         @usableFromInline
-        let beginMask, endMask, ellipsisMask, newAxisMask, squeezeAxisMask: Int64
+        @noDerivative let beginMask, endMask, ellipsisMask, newAxisMask, squeezeAxisMask: Int64
 
         @inlinable
         public init(
@@ -625,13 +625,13 @@ public extension Tensor {
     }
 
     @inlinable
-    // TODO: @differentiable(wrt: self)
+    @differentiable(wrt: self)
     subscript(_ ranges: TensorRangeExpression...) -> Tensor {
         get {
-            return self[IndexPath(ranges.map { $0.tensorRange })]
+            return self[IndexPath({ranges.map { $0.tensorRange }}()).withoutDerivative()]
         }
         set {
-            self[IndexPath(ranges.map { $0.tensorRange })] = newValue
+            self[IndexPath({ranges.map { $0.tensorRange }}()).withoutDerivative()] = newValue
         }
     }
 

From db26abf1fd394ee82ebec9b87447cc5a1fcddeaa Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Thu, 2 May 2019 18:47:50 -0400
Subject: [PATCH 18/55] Brought the 'TensorFlow' module from the apple/swift
 repository.

---
 Package.swift                                 |   12 +-
 Sources/DeepLearning/Core/TensorGroup.swift   |  102 -
 Sources/DeepLearning/Core/TensorHandle.swift  |   26 -
 Sources/DeepLearning/Core/Utilities.swift     |   70 -
 Sources/DeepLearning/Helpers.swift            |   28 -
 .../Context.swift                             |    0
 Sources/TensorFlow/Core/ArrayOps.swift        |  118 +
 Sources/TensorFlow/Core/DataTypes.swift       |  409 ++++
 .../Core/DifferentialOperators.swift          |    2 -
 Sources/TensorFlow/Core/Execution.swift       |   82 +
 Sources/TensorFlow/Core/Helpers.swift         |  168 ++
 .../Core/PythonConversion.swift               |    0
 Sources/TensorFlow/Core/Runtime.swift         | 2126 +++++++++++++++++
 .../Core/ShapedArray.swift                    |    1 -
 .../Core/StringTensor.swift                   |    1 -
 .../Core/Tensor.swift                         |   76 +-
 Sources/TensorFlow/Core/TensorGroup.swift     |  231 ++
 Sources/TensorFlow/Core/TensorHandle.swift    |  269 +++
 Sources/TensorFlow/Core/TensorProtocol.swift  |   51 +
 Sources/TensorFlow/Core/TensorShape.swift     |  167 ++
 Sources/TensorFlow/Core/Threading.swift       |   73 +
 Sources/TensorFlow/Core/Utilities.swift       |  179 ++
 .../Initializers.swift                        |    2 -
 .../{DeepLearning => TensorFlow}/Layer.swift  |    0
 .../{DeepLearning => TensorFlow}/Loss.swift   |    2 -
 .../Operators/Basic.swift                     |   19 +-
 .../Operators/Comparison.swift                |    2 -
 .../Operators/Dataset.swift                   |    2 -
 .../Operators/Math.swift                      |   10 +-
 .../Operators/NN.swift                        |    2 -
 .../Optimizer.swift                           |    0
 .../{DeepLearning => TensorFlow}/Random.swift |    2 -
 Tests/LinuxMain.swift                         |    4 +-
 .../ContextTests.swift                        |    2 +-
 .../InitializerTests.swift                    |    2 +-
 .../LayerTests.swift                          |    2 +-
 .../LossTests.swift                           |    2 +-
 .../OperatorTests/BasicTests.swift            |    2 +-
 .../OperatorTests/ComparisonTests.swift       |    2 +-
 .../OperatorTests/MathTests.swift             |    2 +-
 .../PRNGTests.swift                           |    2 +-
 .../SequentialTests.swift                     |    2 +-
 .../TensorTests.swift                         |    2 +-
 .../TrivialModelTests.swift                   |    2 +-
 .../XCTestManifests.swift                     |    0
 45 files changed, 3921 insertions(+), 337 deletions(-)
 delete mode 100644 Sources/DeepLearning/Core/TensorGroup.swift
 delete mode 100644 Sources/DeepLearning/Core/TensorHandle.swift
 delete mode 100644 Sources/DeepLearning/Core/Utilities.swift
 delete mode 100644 Sources/DeepLearning/Helpers.swift
 rename Sources/{DeepLearning => TensorFlow}/Context.swift (100%)
 create mode 100644 Sources/TensorFlow/Core/ArrayOps.swift
 create mode 100644 Sources/TensorFlow/Core/DataTypes.swift
 rename Sources/{DeepLearning => TensorFlow}/Core/DifferentialOperators.swift (99%)
 create mode 100644 Sources/TensorFlow/Core/Execution.swift
 create mode 100644 Sources/TensorFlow/Core/Helpers.swift
 rename Sources/{DeepLearning => TensorFlow}/Core/PythonConversion.swift (100%)
 create mode 100644 Sources/TensorFlow/Core/Runtime.swift
 rename Sources/{DeepLearning => TensorFlow}/Core/ShapedArray.swift (99%)
 rename Sources/{DeepLearning => TensorFlow}/Core/StringTensor.swift (99%)
 rename Sources/{DeepLearning => TensorFlow}/Core/Tensor.swift (87%)
 create mode 100644 Sources/TensorFlow/Core/TensorGroup.swift
 create mode 100644 Sources/TensorFlow/Core/TensorHandle.swift
 create mode 100644 Sources/TensorFlow/Core/TensorProtocol.swift
 create mode 100644 Sources/TensorFlow/Core/TensorShape.swift
 create mode 100644 Sources/TensorFlow/Core/Threading.swift
 create mode 100644 Sources/TensorFlow/Core/Utilities.swift
 rename Sources/{DeepLearning => TensorFlow}/Initializers.swift (99%)
 rename Sources/{DeepLearning => TensorFlow}/Layer.swift (100%)
 rename Sources/{DeepLearning => TensorFlow}/Loss.swift (99%)
 rename Sources/{DeepLearning => TensorFlow}/Operators/Basic.swift (98%)
 rename Sources/{DeepLearning => TensorFlow}/Operators/Comparison.swift (99%)
 rename Sources/{DeepLearning => TensorFlow}/Operators/Dataset.swift (99%)
 rename Sources/{DeepLearning => TensorFlow}/Operators/Math.swift (99%)
 rename Sources/{DeepLearning => TensorFlow}/Operators/NN.swift (99%)
 rename Sources/{DeepLearning => TensorFlow}/Optimizer.swift (100%)
 rename Sources/{DeepLearning => TensorFlow}/Random.swift (99%)
 rename Tests/{DeepLearningTests => TensorFlowTests}/ContextTests.swift (98%)
 rename Tests/{DeepLearningTests => TensorFlowTests}/InitializerTests.swift (99%)
 rename Tests/{DeepLearningTests => TensorFlowTests}/LayerTests.swift (99%)
 rename Tests/{DeepLearningTests => TensorFlowTests}/LossTests.swift (99%)
 rename Tests/{DeepLearningTests => TensorFlowTests}/OperatorTests/BasicTests.swift (99%)
 rename Tests/{DeepLearningTests => TensorFlowTests}/OperatorTests/ComparisonTests.swift (97%)
 rename Tests/{DeepLearningTests => TensorFlowTests}/OperatorTests/MathTests.swift (99%)
 rename Tests/{DeepLearningTests => TensorFlowTests}/PRNGTests.swift (99%)
 rename Tests/{DeepLearningTests => TensorFlowTests}/SequentialTests.swift (98%)
 rename Tests/{DeepLearningTests => TensorFlowTests}/TensorTests.swift (98%)
 rename Tests/{DeepLearningTests => TensorFlowTests}/TrivialModelTests.swift (98%)
 rename Tests/{DeepLearningTests => TensorFlowTests}/XCTestManifests.swift (100%)

diff --git a/Package.swift b/Package.swift
index 1ee137e0d..2aa01920f 100644
--- a/Package.swift
+++ b/Package.swift
@@ -18,19 +18,19 @@
 import PackageDescription
 
 let package = Package(
-    name: "DeepLearning",
+    name: "TensorFlow",
     products: [
         .library(
-            name: "DeepLearning",
-            targets: ["DeepLearning"]),
+            name: "TensorFlow",
+            targets: ["TensorFlow"]),
     ],
     dependencies: [],
     targets: [
         .target(
-            name: "DeepLearning",
+            name: "TensorFlow",
             dependencies: []),
         .testTarget(
-            name: "DeepLearningTests",
-            dependencies: ["DeepLearning"]),
+            name: "TensorFlowTests",
+            dependencies: ["TensorFlow"]),
     ]
 )
diff --git a/Sources/DeepLearning/Core/TensorGroup.swift b/Sources/DeepLearning/Core/TensorGroup.swift
deleted file mode 100644
index aae548d99..000000000
--- a/Sources/DeepLearning/Core/TensorGroup.swift
+++ /dev/null
@@ -1,102 +0,0 @@
-// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
-//
-// 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.
-
-import TensorFlowCore
-
-extension Tensor: TensorGroup {
-    @inlinable
-    public static var _unknownShapeList: [TensorShape?] {
-        return [nil]
-    }
-
-    @inlinable
-    public static var _typeList: [TensorDataType] {
-        return [Scalar.tensorFlowDataType]
-    }
-
-    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
-        address!.initialize(to: handle._cTensorHandle)
-    }
-
-    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
-        self.init(handle: TensorHandle(_owning: tensorHandles!.pointee))
-    }
-}
-
-extension _TensorElementLiteral: TensorGroup {
-    @inlinable
-    public static var _unknownShapeList: [TensorShape?] {
-        return [nil]
-    }
-
-    @inlinable
-    public static var _typeList: [TensorDataType] {
-        return [Scalar.tensorFlowDataType]
-    }
-
-    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
-        address!.initialize(to: handle._cTensorHandle)
-    }
-
-    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
-        self.init(handle: TensorHandle(_owning: tensorHandles!.pointee))
-    }
-}
-
-extension StringTensor: TensorGroup {
-    @inlinable
-    public static var _unknownShapeList: [TensorShape?] {
-        return [nil]
-    }
-
-    @inlinable
-    public static var _typeList: [TensorDataType] {
-        return [String.tensorFlowDataType]
-    }
-
-    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
-        address!.initialize(to: handle._cTensorHandle)
-    }
-
-    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
-        self.init(handle: TensorHandle(_owning: tensorHandles!.pointee))
-    }
-}
-
-extension Array: TensorArrayProtocol where Element: TensorGroup {
-    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
-        var ptr = address
-        for elem in self {
-            elem._unpackTensorHandles(into: ptr)
-            ptr = ptr!.advanced(by: Int(elem._tensorHandleCount))
-        }
-    }
-
-    public var _tensorHandleCount: Int32 {
-        return Element._tensorHandleCount * Int32(count)
-    }
-
-    public var _typeList: [TensorDataType] {
-        return Array<TensorDataType>([[TensorDataType]](
-            repeating: Element._typeList,
-            count: Int(Element._tensorHandleCount)).joined())
-    }
-
-    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?, count: Int) {
-        let size = count / Int(Element._tensorHandleCount)
-        self = Array((0..<size).map { Element.init(
-            _owning: tensorHandles?.advanced(by: $0 * Int(Element._tensorHandleCount)))
-        })
-    }
-}
diff --git a/Sources/DeepLearning/Core/TensorHandle.swift b/Sources/DeepLearning/Core/TensorHandle.swift
deleted file mode 100644
index efa91e2b3..000000000
--- a/Sources/DeepLearning/Core/TensorHandle.swift
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
-//
-// 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.
-
-internal extension TensorHandle {
-    /// Create a `ShapedArray` with contents of the underlying `TensorHandle`. If
-    /// the `TensorHandle` is on the accelerator, it will be copied to the host.
-    /// - Returns: A `ShapedArray`.
-    @usableFromInline
-    @inline(never)
-    func makeHostCopy() -> ShapedArray<Scalar> {
-        internalConsistencyCheck(isConcrete)
-        debugLog("Calling makeHostCopy() with c handle \(_cTensorHandle)")
-        return ShapedArray(cTensorHandle: _cTensorHandle)
-    }
-}
diff --git a/Sources/DeepLearning/Core/Utilities.swift b/Sources/DeepLearning/Core/Utilities.swift
deleted file mode 100644
index d595b4645..000000000
--- a/Sources/DeepLearning/Core/Utilities.swift
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
-//
-// 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.
-
-#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
-import Darwin
-#else
-import Glibc
-#endif
-
-@_exported import TensorFlowCore
-
-//===----------------------------------------------------------------------===//
-// Unit test utilities
-//===----------------------------------------------------------------------===//
-// TODO: Move this section to a unit-test only Swift module, once the google
-// internal lit based test infra can handle importing additional Swift modules.
-
-/// This is a generic host-only op that hides the details of its impl in the SIL
-/// code. This makes reading/writing SIL based compiler unit tests simple.
-@inline(never)
-public func _hostOp<T>(_ x: T) {
-  print(x)
-}
-
-@inline(never)
-public func _hostOp<Scalar>(_ x: Tensor<Scalar>) {
-  print(x)
-}
-
-@inline(never)
-public func _hostOp<Scalar : TensorFlowScalar>(_ x: TensorHandle<Scalar>) {
-  print(Tensor(handle: x))
-}
-
-/// Some TPU ops (e.g. infeed/outfeed) require tensor shape info, which the APIs
-/// below can provide.
-///
-/// TODO: Remove these helper APIs, when we have a better shape
-/// inference/propagation design.
-@inlinable @inline(__always)
-public func _scalarTensorWithShape<Scalar>(
-  _ x: Tensor<Scalar>
-) -> Tensor<Scalar> {
-  let ret: TensorHandle<Scalar> =
-    #tfop("Identity", x, T$dtype: Scalar.tensorFlowDataType,
-          __shapes: [TensorShape()])
-  return Tensor<Scalar>(handle: ret)
-}
-
-@inlinable @inline(__always)
-public func _addScalarTensorsWithShape<Scalar>(
-  _ x: Tensor<Scalar>,
-  _ y: Tensor<Scalar>
-) -> Tensor<Scalar> {
-  let ret: TensorHandle<Scalar> =
-    #tfop("Add", x, y, T$dtype: Scalar.tensorFlowDataType,
-          __shapes: [TensorShape()])
-  return Tensor<Scalar>(handle: ret)
-}
diff --git a/Sources/DeepLearning/Helpers.swift b/Sources/DeepLearning/Helpers.swift
deleted file mode 100644
index bb5d133bb..000000000
--- a/Sources/DeepLearning/Helpers.swift
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
-//
-// 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.
-
-/// Returns a tensor with the same shape and scalars as the specified tensor.
-@inlinable
-@differentiable
-public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> {
-    return x
-}
-
-// `pow` is defined in Darwin/Glibc on `Float` and `Double`, but there doesn't exist a generic
-// version for `FloatingPoint`.
-// This is a manual definition.
-@inlinable
-func pow<T: BinaryFloatingPoint>(_ x: T, _ y: T) -> T {
-    return T(pow(Double(x), Double(y)))
-}
diff --git a/Sources/DeepLearning/Context.swift b/Sources/TensorFlow/Context.swift
similarity index 100%
rename from Sources/DeepLearning/Context.swift
rename to Sources/TensorFlow/Context.swift
diff --git a/Sources/TensorFlow/Core/ArrayOps.swift b/Sources/TensorFlow/Core/ArrayOps.swift
new file mode 100644
index 000000000..e8bfc7d43
--- /dev/null
+++ b/Sources/TensorFlow/Core/ArrayOps.swift
@@ -0,0 +1,118 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+import CTensorFlow
+
+public extension Raw {
+    /// Saves tensors in V2 checkpoint format.
+    ///
+    /// By default, saves the named tensors in full.  If the caller wishes to save specific slices 
+    /// of full tensors, "shape_and_slices" should be non-empty strings and correspondingly
+    /// well-formed.
+    ///
+    /// - Parameters:
+    ///   - prefix: Must have a single element. The prefix of the V2 checkpoint to which we write
+    ///     the tensors.
+    ///   - tensor_names: shape {N}. The names of the tensors to be saved.
+    ///   - shape_and_slices: shape {N}.  The slice specs of the tensors to be saved. Empty strings 
+    ///     indicate that they are non-partitioned tensors.
+    ///   - tensors: `N` tensors to save.
+    @inlinable @inline(__always)
+    static func saveV2(
+        prefix: StringTensor,
+        tensorNames: StringTensor,
+        shapeAndSlices: StringTensor,
+        tensors: [AnyTensor]
+    ) {
+        let s: CTFStatus = TF_NewStatus()
+        defer { TF_DeleteStatus(s) }
+        let op: CTFEOp = TFE_NewOp(_ExecutionContext.global.eagerContext, "SaveV2", s)
+        defer { TFE_DeleteOp(op) }
+        let _ = _TFCOpAddInputFromTensorGroup(op, prefix, s)
+        let _ = _TFCOpAddInputFromTensorGroup(op, tensorNames, s)
+        let _ = _TFCOpAddInputFromTensorGroup(op, shapeAndSlices, s)
+        let _ = _TFCOpAddInputFromAnyTensors(op, tensors, s)
+        let _ = _TFCOpSetAttrTypeArray(op, "dtypes", tensors.map { $0._tensorFlowDataType })
+
+        // Execute the op.
+        var count: Int32 = 0
+        var unused: CTensorHandle?
+        _TFCOpSetDeviceFromScope(op, s)
+        checkOk(s)
+        _TFCEagerExecute(op, &unused, &count, s)
+        checkOk(s)
+        TFE_DeleteOp(op)
+        TF_DeleteStatus(s)
+    }
+
+    /// Restores tensors from a V2 checkpoint.
+    ///
+    /// For backward compatibility with the V1 format, this Op currently allows restoring from a V1 
+    /// checkpoint as well:
+    ///   - This Op first attempts to find the V2 index file pointed to by "prefix", and if found 
+    ///     proceed to read it as a V2 checkpoint;
+    ///   - Otherwise the V1 read path is invoked.
+    /// Relying on this behavior is not recommended, as the ability to fall back to read V1 might be 
+    /// deprecated and eventually removed.
+    ///
+    /// By default, restores the named tensors in full.  If the caller wishes to restore specific 
+    /// slices of stored tensors, "shape_and_slices" should be non-empty strings and correspondingly 
+    /// well-formed.
+    ///
+    /// Callers must ensure all the named tensors are indeed stored in the checkpoint.
+    ///
+    /// - Parameters:
+    ///   - prefix: Must have a single element.  The prefix of a V2 checkpoint.
+    ///   - tensor_names: shape {N}.  The names of the tensors to be restored.
+    ///   - shape_and_slices: shape {N}.  The slice specs of the tensors to be restored. Empty
+    ///     strings indicate that they are non-partitioned tensors.
+    ///
+    /// - Attr dtypes: shape {N}.  The list of expected dtype for the tensors. Must match those
+    ///   stored in the checkpoint.
+    ///
+    /// - Output tensors: shape {N}.  The restored tensors, whose shapes are read from the 
+    ///   checkpoint directly.
+    @inlinable @inline(__always)
+    static func restoreV2(
+        prefix: StringTensor,
+        tensorNames: StringTensor,
+        shapeAndSlices: StringTensor,
+        dtypes: [TensorDataType]
+    ) -> [AnyTensor] {
+        let s: CTFStatus = TF_NewStatus()
+        defer { TF_DeleteStatus(s) }
+        let op: CTFEOp = TFE_NewOp(_ExecutionContext.global.eagerContext, "RestoreV2", s)
+        defer { TFE_DeleteOp(op) }
+        let _ = _TFCOpAddInputFromTensorGroup(op, prefix, s)
+        let _ = _TFCOpAddInputFromTensorGroup(op, tensorNames, s)
+        let _ = _TFCOpAddInputFromTensorGroup(op, shapeAndSlices, s)
+        let _ = _TFCOpSetAttrTypeArray(op, "dtypes", dtypes)
+
+        var count: Int32 = Int32(dtypes.count)
+        let buffer: UnsafeMutablePointer<CTensorHandle> =
+        UnsafeMutablePointer.allocate(capacity: Int(count))
+        defer { buffer.deallocate() }
+        _TFCOpSetDeviceFromScope(op, s)
+        _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, s)
+        checkOk(s)
+
+        var out: [AnyTensor] = []
+        var cursor = buffer
+        for type in dtypes {
+            out.append(makeTensor(dataType: type, owning: cursor.pointee))
+            cursor = cursor.advanced(by: 1)
+        }
+        return out
+    }
+}
diff --git a/Sources/TensorFlow/Core/DataTypes.swift b/Sources/TensorFlow/Core/DataTypes.swift
new file mode 100644
index 000000000..1e95173c5
--- /dev/null
+++ b/Sources/TensorFlow/Core/DataTypes.swift
@@ -0,0 +1,409 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+import CTensorFlow
+
+/// A TensorFlow dynamic type value that can be created from types that conform to 
+/// `TensorFlowScalar`.
+// This simply wraps a `TF_DataType` and allows user code to handle `TF_DataType` without importing
+// CTensorFlow, which pollutes the namespace with TensorFlow C API declarations.
+@_fixed_layout
+public struct TensorDataType {
+    public var _cDataType: TF_DataType
+
+    @inlinable
+    public init(_ cDataType: TF_DataType) {
+        self._cDataType = cDataType
+    }
+}
+
+@usableFromInline
+internal func makeTensor(
+    dataType: TensorDataType,
+    owning pointer: CTensorHandle
+) -> AnyTensor {
+    switch dataType._cDataType {
+    case TF_BOOL: return Tensor<Bool>(handle: TensorHandle(_owning: pointer))
+    case TF_INT8: return Tensor<Int8>(handle: TensorHandle(_owning: pointer))
+    case TF_UINT8: return Tensor<UInt8>(handle: TensorHandle(_owning: pointer))
+    case TF_INT16: return Tensor<Int16>(handle: TensorHandle(_owning: pointer))
+    case TF_UINT16: return Tensor<UInt16>(handle: TensorHandle(_owning: pointer))
+    case TF_INT32: return Tensor<Int32>(handle: TensorHandle(_owning: pointer))
+    case TF_UINT32: return Tensor<UInt32>(handle: TensorHandle(_owning: pointer))
+    case TF_INT64: return Tensor<Int64>(handle: TensorHandle(_owning: pointer))
+    case TF_UINT64: return Tensor<UInt64>(handle: TensorHandle(_owning: pointer))
+    case TF_BFLOAT16: return Tensor<BFloat16>(handle: TensorHandle(_owning: pointer))
+    case TF_FLOAT: return Tensor<Float>(handle: TensorHandle(_owning: pointer))
+    case TF_DOUBLE: return Tensor<Double>(handle: TensorHandle(_owning: pointer))
+    case TF_STRING: fatalError("StringTensor does not conform to AnyTensor")
+    default: fatalError("Unhandled type: \(dataType)")
+    }
+}
+
+/// A data type compatible with TensorFlow.
+public protocol _TensorFlowDataTypeCompatible {
+    /// The underlying TensorFlow data type.
+    @inlinable
+    static var tensorFlowDataType: TensorDataType { get }
+
+    // Hooks used by the TFPartition pass for primitive operations on tensors. These should not be
+    // called directly or implemented.
+
+    /// This converts a TensorHandle that is known to have a 0d value into the scalar that it
+    /// produces. Users should call the _TFGetScalarOrDie wrapper function.
+    static func _getScalarOrDie(_ handle: TensorHandle<Self>) -> Self
+
+    /// This converts a TensorHandle into a scalar if it is 0d, or returns nil otherwise. Users
+    /// should call the _TFGetScalar wrapper function.
+    static func _getScalar(_ handle: TensorHandle<Self>) -> Self?
+
+    /// This indicates that it is safe to hoist the specified computation that creates a tensor to 
+    /// being a parameter that is passed in from outside of the tensor program.
+    static func _hoistableClosure(_ fn: () -> TensorHandle<Self>) -> TensorHandle<Self>
+}
+
+/// A scalar data type compatible with TensorFlow.
+///
+/// Types that conform to `TensorFlowScalar` can be used as the `Scalar` associated type of
+/// `Tensor`.
+//
+// This includes all `_TensorFlowDataTypeCompatible` types except `String`.
+public protocol TensorFlowScalar: _TensorFlowDataTypeCompatible {}
+
+public typealias TensorFlowNumeric = TensorFlowScalar & Numeric
+public typealias TensorFlowSignedNumeric = TensorFlowScalar & SignedNumeric
+public typealias TensorFlowInteger = TensorFlowScalar & BinaryInteger
+
+/// A floating-point data type that conforms to `Differentiable` and is compatible with TensorFlow.
+///
+/// - Note: `Tensor` conditionally conforms to `Differentiable` when the `Scalar` associated type
+///   conforms `TensorFlowFloatingPoint`.
+public protocol TensorFlowFloatingPoint: TensorFlowScalar & BinaryFloatingPoint & Differentiable
+    where Self.RawSignificand: FixedWidthInteger,
+          Self == Self.TangentVector,
+          Self == Self.CotangentVector,
+          Self == Self.AllDifferentiableVariables {}
+
+extension Float: TensorFlowFloatingPoint {}
+extension Double: TensorFlowFloatingPoint {}
+
+// This is the implementation of the _getScalarOrDie requirement for each concrete type below. We 
+// use this round-about approach to implement the global _TFGetScalarOrDie function in order to 
+// ensure that the noinline SIL functions below have non-generic type signatures. This is important 
+// for the inner workings of the partitioning pass.
+private func _TFGetScalarOrDieImpl<Scalar>(_ handle: TensorHandle<Scalar>) -> Scalar {
+    return handle.makeHostCopy().scalar!
+}
+
+// This is the implementation of the _getScalar requirement for each concrete type below. We use 
+// this round-about approach to implement the global _TFGetScalar function in order to ensure that 
+// the noinline SIL functions below have non-generic type signatures.  This is important for the 
+// inner workings of the partitioning pass.
+private func _TFGetScalarImpl<Scalar>(_ handle: TensorHandle<Scalar>) -> Scalar? {
+    return handle.makeHostCopy().scalar
+}
+
+extension Bool: TensorFlowScalar {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_BOOL)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_Bool") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<Bool>) -> Bool {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_Bool") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<Bool>) -> Bool? {
+        return _TFGetScalarImpl(handle)
+    }
+
+    @_silgen_name("__tf_hoistable_Bool") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(_ fn: () -> TensorHandle<Bool>) -> TensorHandle<Bool> {
+        return fn()
+    }
+}
+
+extension Int8: TensorFlowScalar {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_INT8)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_Int8") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<Int8>) -> Int8 {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_Int8") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<Int8>) -> Int8? {
+        return _TFGetScalarImpl(handle)
+    }
+
+    @_silgen_name("__tf_hoistable_Int8") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(_ fn: () -> TensorHandle<Int8>) -> TensorHandle<Int8> {
+        return fn()
+    }
+}
+
+extension UInt8: TensorFlowScalar {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_UINT8)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_UInt8") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<UInt8>) -> UInt8 {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_UInt8") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<UInt8>) -> UInt8? {
+        return _TFGetScalarImpl(handle)
+    }
+
+    @_silgen_name("__tf_hoistable_UInt8") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(_ fn: () -> TensorHandle<UInt8>) -> TensorHandle<UInt8> {
+        return fn()
+    }
+}
+
+extension Int16: TensorFlowScalar {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_INT16)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_Int16") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<Int16>) -> Int16 {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_Int16") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<Int16>) -> Int16? {
+        return _TFGetScalarImpl(handle)
+    }
+
+    @_silgen_name("__tf_hoistable_Int16") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(_ fn: () -> TensorHandle<Int16>) -> TensorHandle<Int16> {
+        return fn()
+    }
+}
+
+extension UInt16: TensorFlowScalar {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_UINT16)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_UInt16") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<UInt16>) -> UInt16 {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_UInt16") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<UInt16>) -> UInt16? {
+        return _TFGetScalarImpl(handle)
+    }
+
+    @_silgen_name("__tf_hoistable_UInt16") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(_ fn: () -> TensorHandle<UInt16>) -> TensorHandle<UInt16> {
+        return fn()
+    }
+}
+
+extension Int32: TensorFlowScalar {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_INT32)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_Int32") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<Int32>) -> Int32 {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_Int32") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<Int32>) -> Int32? {
+        return _TFGetScalarImpl(handle)
+    }
+
+    @_silgen_name("__tf_hoistable_Int32") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(_ fn: () -> TensorHandle<Int32>) -> TensorHandle<Int32> {
+        return fn()
+    }
+}
+
+extension UInt32: TensorFlowScalar {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_UINT32)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_UInt32") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<UInt32>) -> UInt32 {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_UInt32") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<UInt32>) -> UInt32? {
+        return _TFGetScalarImpl(handle)
+    }
+
+    @_silgen_name("__tf_hoistable_UInt32") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(_ fn: () -> TensorHandle<UInt32>) -> TensorHandle<UInt32> {
+        return fn()
+    }
+}
+
+extension Int64: TensorFlowScalar {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_INT64)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_Int64") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<Int64>) -> Int64 {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_Int64") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<Int64>) -> Int64? {
+        return _TFGetScalarImpl(handle)
+    }
+
+    @_silgen_name("__tf_hoistable_Int64") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(_ fn: () -> TensorHandle<Int64>) -> TensorHandle<Int64> {
+        return fn()
+    }
+}
+
+extension UInt64: TensorFlowScalar {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_UINT64)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_UInt64") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<UInt64>) -> UInt64 {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_UInt64") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<UInt64>) -> UInt64? {
+        return _TFGetScalarImpl(handle)
+    }
+
+    @_silgen_name("__tf_hoistable_UInt64") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(_ fn: () -> TensorHandle<UInt64>) -> TensorHandle<UInt64> {
+        return fn()
+    }
+}
+
+@_fixed_layout
+public struct BFloat16 {
+    @usableFromInline var data: Int16 = 0
+    private init() {}
+}
+
+extension BFloat16: TensorFlowScalar {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_BFLOAT16)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_BFloat16") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<BFloat16>) -> BFloat16 {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_BFloat16") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<BFloat16>) -> BFloat16? {
+        return _TFGetScalarImpl(handle)
+    }
+
+    @_silgen_name("__tf_hoistable_BFloat16") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(
+        _ fn: () -> TensorHandle<BFloat16>
+    ) -> TensorHandle<BFloat16> {
+        return fn()
+    }
+}
+
+extension Float: TensorFlowScalar {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_FLOAT)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_Float") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<Float>) -> Float {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_Float") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<Float>) -> Float? {
+        return _TFGetScalarImpl(handle)
+    }
+
+    @_silgen_name("__tf_hoistable_Float") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(_ fn: () -> TensorHandle<Float>) -> TensorHandle<Float> {
+        return fn()
+    }
+}
+
+extension Double: TensorFlowScalar {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_DOUBLE)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_Double") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<Double>) -> Double {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_Double") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<Double>) -> Double? {
+        return _TFGetScalarImpl(handle)
+    }
+
+    @_silgen_name("__tf_hoistable_Double") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(_ fn: () -> TensorHandle<Double>) -> TensorHandle<Double> {
+        return fn()
+    }
+}
+
+extension String: _TensorFlowDataTypeCompatible {
+    @inlinable
+    public static var tensorFlowDataType: TensorDataType {
+        return TensorDataType(TF_STRING)
+    }
+
+    @_silgen_name("__tf_get_scalar_or_die_String") @inline(never)
+    public static func _getScalarOrDie(_ handle: TensorHandle<String>) -> String {
+        return _TFGetScalarOrDieImpl(handle)
+    }
+
+    @_silgen_name("__tf_get_scalar_String") @inline(never)
+    public static func _getScalar(_ handle: TensorHandle<String>) -> String? {
+        return _TFGetScalarImpl(handle)
+    }
+    
+    @_silgen_name("__tf_hoistable_String") @_optimize(none) @inline(never)
+    public static func _hoistableClosure(_ fn: () -> TensorHandle<String>) -> TensorHandle<String> {
+        return fn()
+    }
+}
diff --git a/Sources/DeepLearning/Core/DifferentialOperators.swift b/Sources/TensorFlow/Core/DifferentialOperators.swift
similarity index 99%
rename from Sources/DeepLearning/Core/DifferentialOperators.swift
rename to Sources/TensorFlow/Core/DifferentialOperators.swift
index 9fade54b9..c576478b5 100644
--- a/Sources/DeepLearning/Core/DifferentialOperators.swift
+++ b/Sources/TensorFlow/Core/DifferentialOperators.swift
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 //===------------------------------------------------------------------------------------------===//
 // Method-style Differential Operators
 //===------------------------------------------------------------------------------------------===//
diff --git a/Sources/TensorFlow/Core/Execution.swift b/Sources/TensorFlow/Core/Execution.swift
new file mode 100644
index 000000000..b2c36fa20
--- /dev/null
+++ b/Sources/TensorFlow/Core/Execution.swift
@@ -0,0 +1,82 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+// If `serverAddress` is nil, use local session (good for forge testing).
+//
+// FIXME: We need transparent here because deabstraction isn't inlining this function.  We need to 
+// inline if a callee contains tensor ops, not only if it takes and returns a TensorFlow value.
+@_transparent
+public func enableTPU(serverAddress: String? = nil, infeed: Bool = true) {
+    _RuntimeConfig.executionMode = .tpu
+    if let serverAddress = serverAddress {
+        _RuntimeConfig.session = .remote(serverDef: serverAddress)
+    }
+    #tfop("tfc.configureTPU", enableInfeed: infeed) as Void
+}
+
+// FIXME: Extend the interface to support multiple GPU devices, and unify it with enableTPU() above.
+@_transparent
+public func enableGPU() {
+    #tfop("tfc.configureGPU") as Void
+}
+
+@_transparent
+public func enableCPU() {
+    #tfop("tfc.configureCPU") as Void
+}
+
+/// A TensorFlow device kind.
+public enum DeviceKind {
+    /// The CPU device kind.
+    case cpu
+    /// The GPU device kind.
+    case gpu
+    /// The TPU device kind.
+    case tpu
+}
+
+/// Executes a closure, making TensorFlow operations run on a specific kind of device.
+///
+/// - Parameters:
+///   - kind: A kind of device to run TensorFlow operations on.
+///   - index: The device to run the ops on.
+///   - body: A closure whose TensorFlow operations are to be executed on the
+///     specified kind of device.
+// Use `@inline(never)` to ensure correctness in scoped device placement. See
+// https://bugs.swift.org/browse/SR-9535 for more context.
+@inline(never)
+public func withDevice<R>(
+    _ kind: DeviceKind,
+    _ index: UInt = 0,
+    perform body: () throws -> R
+) rethrows -> R {
+    _ThreadLocalState.value.pushDevice((kind, index))
+    let result = try body()
+    _ThreadLocalState.value.popDevice()
+    return result
+}
+
+/// Executes a closure, allowing TensorFlow to place TensorFlow operations on any device. This
+/// should restore the default placement behavior.
+///
+/// - Parameters:
+///   - body: A closure whose TensorFlow operations are to be executed on the specified kind of 
+///     device.
+@inline(never)
+public func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R {
+    _ThreadLocalState.value.pushDevice(nil)
+    let result = try body()
+    _ThreadLocalState.value.popDevice()
+    return result
+}
diff --git a/Sources/TensorFlow/Core/Helpers.swift b/Sources/TensorFlow/Core/Helpers.swift
new file mode 100644
index 000000000..e1ed01225
--- /dev/null
+++ b/Sources/TensorFlow/Core/Helpers.swift
@@ -0,0 +1,168 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+import CTensorFlow
+
+//===------------------------------------------------------------------------------------------===//
+// Tensor
+//===------------------------------------------------------------------------------------------===//
+
+/// This function converts a `TensorHandle` that is known to have a 0-d value
+/// into the scalar that it produces. This is intended for use in op definitions
+/// where it is known that the op always returns a 0-d tensor. It is not for use
+/// in general code.
+@inlinable @inline(__always)
+public func _TFGetScalarOrDie<Scalar: TensorFlowScalar>(_ handle: TensorHandle<Scalar>) -> Scalar {
+  return Scalar._getScalarOrDie(handle)
+}
+
+/// This function converts a `TensorHandle` into a scalar if it is 0-d, or returns nil otherwise.
+@inlinable @inline(__always)
+public func _TFGetScalar<Scalar: TensorFlowScalar>(_ handle: TensorHandle<Scalar>) -> Scalar? {
+  return Scalar._getScalar(handle)
+}
+
+/// This compiler builtin is known by the partitioning pass, which recognizes it
+/// and promotes calls to it to being in graph when it can. This signature was
+/// designed to align with the requirements of the `Const` TensorFlow operation.
+@inlinable @inline(never)
+@_silgen_name("__tf_tensor_from_scalars")
+public func _TFTensorFromScalars<Scalar: TensorFlowScalar>(
+    _ scalars: [Scalar], shape: [Int]
+) -> TensorHandle<Scalar> {
+    let contiguousSize = shape.reduce(1, *)
+    precondition(scalars.count == contiguousSize, "The number of scalars does not match the shape.")
+    return TensorHandle(
+        shape: shape,
+        scalarsInitializer: { addr in
+            scalars.withUnsafeBufferPointer { ptr in
+                addr.assign(from: ptr.baseAddress!, count: contiguousSize)
+            }
+        })
+}
+
+/// In graph mode, the deabstraction pass transforms this function call to
+/// either a "Const" graph_op (if `scalar` is a compile-time constant), or a
+/// "tfc.scalarToTensor" graph_op. In the latter case, the partition pass uses
+/// it to do scalar promotion, and transforms it away before entering graph
+/// lowering. e.g. For user code:
+///   let x_scalar = x_tensor.mean()
+///   let y_scalar = y_tensor.mean()
+///   let z_scalar = x_scalar + y_scalar
+///   let z_tensor = Tensor(z_scalar)
+///
+/// The scalar addition can be promoted into graph, through the
+/// "tfc.scalarToTensor" graph_op generated from Tensor(z_scalar). In this
+/// example, the _getScalarOrDie() call generated from mean() will be "cancelled
+/// out" with "tfc.scalarToTensor", such that we avoid generating scalar on the
+/// host, and then converting it back to a graph tensor.
+///
+/// In eager mode, this function is executed directly.
+@inlinable @inline(never)
+@_silgen_name("__tf_tensor_from_scalar")
+public func _TFTensorFromScalar<Scalar: TensorFlowScalar>(
+    _ scalar: Scalar
+) -> TensorHandle<Scalar> {
+    return _TFTensorFromScalars([scalar], shape: [])
+}
+
+@inlinable @inline(never)
+@_silgen_name("__tf_tensor_from_scalars_1d")
+public func _TFTensorFromScalars1D<Scalar: TensorFlowScalar>(
+    _ scalars: [Scalar]
+) -> TensorHandle<Scalar> {
+    return _TFTensorFromScalars(scalars, shape: [scalars.count])
+}
+
+@inlinable @inline(__always)
+public func _TFHoistable<Scalar>(_ fn: () -> TensorHandle<Scalar>) -> TensorHandle<Scalar> {
+    return Scalar._hoistableClosure(fn)
+}
+
+//===------------------------------------------------------------------------------------------===//
+// StringTensor
+//===------------------------------------------------------------------------------------------===//
+
+/// This compiler builtin is known by the partitioning pass, which recognizes it
+/// and promotes calls to it to being in graph when it can. This signature was
+/// designed to align with the requirements of the `Const` TensorFlow operation.
+@inlinable @inline(never)
+@_silgen_name("__tf_string_tensor_from_strings")
+public func _TFStringTensorFromStrings(_ scalars: [String], shape: [Int]) -> TensorHandle<String> {
+    let contiguousSize = shape.reduce(1, *)
+    precondition(scalars.count == contiguousSize, "The number of scalars does not match the shape.")
+
+    // utf8CString is null-terminated. TF APIs want the strings without null-terminators.
+    let cStrings = scalars.map { $0.utf8CString.dropLast() }
+
+    let tfEncodedSizes = cStrings.map { TF_StringEncodedSize($0.count) }
+
+    // Format information copied from tensorflow/c/c_api.h:
+    // The format for TF_STRING tensors is:
+    //   start_offset: array[uint64]
+    //   data:         byte[...]
+    //
+    //   The string length (as a varint), followed by the contents of the string
+    //   is encoded at data[start_offset[i]]].
+
+    // The size of the "start_offset" region.
+    let startOffsetsByteCount = scalars.count * MemoryLayout<UInt64>.stride
+
+    // The size of the "data" region.
+    let dataByteCount = tfEncodedSizes.reduce(0, +) * MemoryLayout<UInt8>.stride
+
+    return TensorHandle(
+        shape: shape,
+        byteCount: startOffsetsByteCount + dataByteCount,
+        bufferInitializer: { tensorBuffer in
+            // Initialize the "start_offset" region.
+            var startOffset: UInt64 = 0
+            var startOffsetAddr = tensorBuffer.bindMemory(to: UInt64.self, capacity: scalars.count)
+            for tfEncodedSize in tfEncodedSizes {
+                startOffsetAddr.initialize(to: startOffset)
+                startOffsetAddr = startOffsetAddr.advanced(by: 1)
+                startOffset = startOffset + UInt64(tfEncodedSize)
+            }
+
+            // Initialize the "data" region.
+            var dataAddr = tensorBuffer.advanced(by: startOffsetsByteCount)
+                .bindMemory(to: Int8.self, capacity: dataByteCount)
+            let status = TF_NewStatus()
+            for (cString, tfEncodedSize) in zip(cStrings, tfEncodedSizes) {
+                _ = cString.withUnsafeBufferPointer { buffer in
+                    TF_StringEncode(
+                        buffer.baseAddress,
+                        buffer.count,
+                        dataAddr,
+                        tfEncodedSize,
+                        status)
+                }
+                checkOk(status)
+                dataAddr = dataAddr.advanced(by: tfEncodedSize)
+            }
+            TF_DeleteStatus(status)
+        })
+}
+
+@inlinable @inline(never)
+@_silgen_name("__tf_string_tensor_from_string")
+public func _TFStringTensorFromString(_ scalar: String) -> TensorHandle<String> {
+    return _TFStringTensorFromStrings([scalar], shape: [])
+}
+
+@inlinable @inline(never)
+@_silgen_name("__tf_string_tensor_from_strings_1d")
+public func _TFStringTensorFromStrings1D(_ scalars: [String]) -> TensorHandle<String> {
+    return _TFStringTensorFromStrings(scalars, shape: [scalars.count])
+}
diff --git a/Sources/DeepLearning/Core/PythonConversion.swift b/Sources/TensorFlow/Core/PythonConversion.swift
similarity index 100%
rename from Sources/DeepLearning/Core/PythonConversion.swift
rename to Sources/TensorFlow/Core/PythonConversion.swift
diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
new file mode 100644
index 000000000..6fccfecbd
--- /dev/null
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -0,0 +1,2126 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+// This file defines the Swift runtime support for TensorFlow computation.
+//
+// This file should only contain internal details: runtime-related public APIs
+// should be defined in `Execution.swift`.
+//
+// Design notes on TF eager based runtime:
+//
+// 1. A global context (`_ExecutionContext.global`) is used to manage all tensor
+// computation and transfers.
+//
+// 2. When the tensor computation involves N device functions, run them in N
+// threads (but with the same execution/eager context). In addition, run the
+// host-side of sends/recvs in the main thread. These N + 1 threads form
+// "coroutines", and use sends/recvs mechanisms to communicate and unblock each
+// other's progress.
+// 2a) The sends/recvs mechanism between host and TF is the enqueue / dequeue
+// operations on TF (CPU-based) Fifo queues. Only tensor handles are transferred
+// in these enqueue / dequeue operations. For host to consume the content of the
+// tensor sent from TF, it uses TFE_TensorHandleResolve().
+// 2b) The sends/recvs mechanism between TF devices is the _Send / _Recv TF ops.
+//
+// Potential TODOs:
+// - Support async on platforms other than Linux and FreeBSD.
+// - Revisit the concurrency model and see if Dispatch can be built without
+//   Foundation.
+//
+//===----------------------------------------------------------------------===//
+
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+import Darwin
+#else
+import Glibc
+#endif
+import CTensorFlow
+
+// @_frozen // SR-9739
+public enum _ExecutionMode : Equatable {
+  /// CPU or GPU execution.
+  case auto
+  /// TPU execution.
+  // TODO: assess if we can pass this bit of info from compiler settings (when
+  // enableTPU() is called), and avoid having this additional runtime bit.
+  case tpu
+  /// XLA jit-compilation backend (will use GPU when available, and otherwise
+  /// CPU).
+  case xla
+
+  public var isTPU: Bool {
+    switch self {
+    case .tpu: return true
+    default: return false
+    }
+  }
+}
+
+/// TraceContext contains the state needed to build a trace graph function
+/// (TF_Function). As eager ops are executed in tracing mode, their
+/// corresponding nodes are added to the trace graph (via
+/// `addEagerOpToGraph()`). When the trace is finalized (via `finalize()`), the
+/// trace graph function can then be executed (via `execute()`) by the eager
+/// runtime.
+@usableFromInline
+internal class TraceContext {
+  let status: CTFStatus = TF_NewStatus()
+
+  /// The trace graph, which will be converted to a trace graph function
+  /// (TF_Function) upon finalizing.
+  let graph = TF_NewGraph()
+
+  /// The list of inputs to the trace graph function. It starts with the inputs
+  /// to the function that we trace (referred to as the "tracee function" or
+  /// "tracee"), followed by possible additional inputs that correspond to
+  /// concrete tensors produced within the trace function.
+  ///
+  /// For example, if the tracee is:
+  ///
+  /// struct TensorPair<T : TensorGroup, U : TensorGroup> : TensorGroup {
+  ///   public var first: T
+  ///   public var second: U
+  /// }
+  ///
+  /// func foo(x: TensorPair) -> Tensor {
+  ///   let y = Tensor<Float>(1.0)
+  ///   return x.first + x.second + y
+  /// }
+  ///
+  /// Then the generated trace graph function has 3 input tensors: x.first,
+  /// x.second, and y.
+  ///
+  /// These symbolic tensors corresond to PlaceHolder nodes in the trace graph,
+  /// and will be filled in when we execute the trace graph function.
+  //
+  // TODO: If some tensors in `x` are not used within `foo()`, they can be
+  // pruned away in the inputs to the trace graph function.
+  var symbolicInputs: [TF_Output] = []
+
+  /// The outputs obtained by executing the `tracee` for computing the trace.
+  var tracedOutputs: [CTensorHandle] = []
+
+  /// The trace context object used in TF C API calls that convert eager ops to
+  /// (trace) graph nodes.
+  let cTraceContext: CTFETraceContext
+
+  /// The trace graph function created by `finalize()`.
+  var traceGraphFn: CTFFunction?
+
+  /// The number of additional input tensors to the trace graph function,
+  /// created from concrete intermediate tensors in the tracee, such as `y` in
+  /// the code snippet above.
+  var additionalInputTensorCount: Int32 = -1
+
+  /// `dtypes` is the (flattened) list of TF_DataType of input tensors
+  /// to the trace function.
+  init(dtypes: [TF_DataType]) {
+    debugLog("Instiantiating TraceContext with \(dtypes.count) input tensors.")
+    for (i, dtype) in dtypes.enumerated() {
+      let desc = TF_NewOperation(graph, "Placeholder", "input_\(i)")
+      TF_SetAttrType(desc, "dtype", dtype)
+      let result = TF_FinishOperation(desc, status)
+      checkOk(status)
+      symbolicInputs.append(TF_Output(oper: result, index: 0))
+    }
+    cTraceContext = TFE_NewTraceContext(graph)
+  }
+
+  deinit {
+    TFE_DeleteTraceContext(cTraceContext)
+    TF_DeleteGraph(graph)
+    TF_DeleteStatus(status)
+  }
+
+  @usableFromInline
+  func addEagerOpToGraph(_ op: CTFEOp,
+                      _ retvals: UnsafeMutablePointer<OpaquePointer?>,
+                      _ retvalCount: UnsafeMutablePointer<Int32>,
+                      _ status: CTFStatus) {
+    TFE_AddEagerOpToGraph(op, cTraceContext, retvals, retvalCount, status)
+    checkOk(status)
+  }
+
+  /// Finalize the trace graph function.
+  func finalize(traceeBasicName: String) {
+    internalConsistencyCheck(traceGraphFn == nil)
+    var symbolicOutputs: [TF_Output] = []
+    // Only add symbolic output tensors as the outputs of the trace graph function.
+    // For example, let the tracee be:
+    //   func foo(x: Tensor) -> (Tensor, Tensor) {
+    //     let y = Tensor<Float>(1.0)
+    //     return (x + x, y)
+    //   }
+    //
+    // Here foo() returns 2 tensors, but only the first one (as computed by x +
+    // x) is symbolic. The second one for y is concrete, and is computed at
+    // trace creation time, not trace execution time.
+    // Also see the comment block above finalizeAndExecuteTraceFn().
+    for (i, tracedOutput) in tracedOutputs.enumerated()
+        where TFE_TensorHandleIsConcrete(tracedOutput) == 0 {
+      debugLog("Adding symbolic tracedOutput \(i) as a trace graph func output.")
+      symbolicOutputs.append(TFE_GetTFOutputFromTensorHandle(tracedOutput ,status))
+      checkOk(status)
+    }
+
+    let traceeInputCount = symbolicInputs.count
+    // Append concrete tensors created within the tracee as symbolic inputs to
+    // the generated trace graph function.
+    additionalInputTensorCount = TFE_FinalizeInputTensorsFromTraceContext(
+      cTraceContext)
+    for i in 0..<additionalInputTensorCount {
+      symbolicInputs.append(TFE_GetInputGraphNodeFromTraceContext(
+                              cTraceContext, UInt32(i)))
+    }
+
+    let tracedFunctionName =
+      "\(traceeBasicName)_\(_RuntimeConfig.traceGraphFunctionCounter)"
+    _RuntimeConfig.traceGraphFunctionCounter += 1
+    debugLog("""
+               Finalizing trace graph func \(tracedFunctionName), with \
+               \(traceeInputCount) tracee inputs and \
+               \(additionalInputTensorCount) additional inputs, and up to \
+               \(tracedOutputs.count) return values.
+               """)
+    traceGraphFn =
+      TF_GraphToFunction(graph, tracedFunctionName,
+                         /*append_hash_to_fn_name*/ 0,
+                         /*num_opers*/ -1,
+                         /*opers*/ nil,
+                         /*numinputs*/ Int32(symbolicInputs.count),
+                         /*inputs*/ symbolicInputs,
+                         /*noutputs*/ Int32(symbolicOutputs.count),
+                         /*outputs*/ symbolicOutputs,
+                         /*outputnames*/ nil,
+                         /*functionoptions*/ nil, "", status)
+    checkOk(status)
+
+    if _RuntimeConfig.printsDebugLog {
+      var len: Int = 0
+      let funcDebugStr = TF_FunctionDebugString(traceGraphFn, &len)!
+      debugLog("The traced function is:\n\(String(cString: funcDebugStr))")
+      free(funcDebugStr)
+    }
+
+    // TODO: Consider garbage-collecting these trace graph functions if we end
+    // up with many of them.
+    let eagerContext = _TFCGetGlobalEagerContext()
+    TFE_ContextAddFunction(eagerContext, traceGraphFn, status)
+    checkOk(status)
+  }
+
+  /// Execute the trace graph function, and return the list of output tensors
+  /// from the trace execution. These output tensors are owned by the caller.
+  func execute(
+    traceeInputs: [_AnyTensorHandle], useXLA: Bool = false) -> [CTensorHandle] {
+    // We must be in the `notTracing` enum mode.
+    internalConsistencyCheck(_RuntimeConfig.traceState.context == nil)
+    internalConsistencyCheck(traceGraphFn != nil)
+
+    let tracedFunctionName = TF_FunctionName(traceGraphFn)
+    internalConsistencyCheck(tracedFunctionName != nil)
+    let eagerContext = _TFCGetGlobalEagerContext()
+    let op: CTFEOp! = TFE_NewOp(eagerContext, tracedFunctionName, status)
+    defer { TFE_DeleteOp(op) }
+    checkOk(status)
+
+    let deviceName = _ExecutionContext.global.currentDeviceName
+    if let deviceName = deviceName {
+      debugLog("Placing the trace func on device \(deviceName).")
+      TFE_OpSetDevice(op, deviceName, status)
+      checkOk(status)
+    }
+
+    if useXLA {
+      debugLog("Enabling XLA compilation")
+      TFE_OpSetAttrBool(op, "_XlaCompile", 1)
+    }
+
+    debugLog("Adding \(traceeInputs.count) tracee input tensors.")
+    internalConsistencyCheck(symbolicInputs.count == traceeInputs.count
+                               + Int(additionalInputTensorCount))
+    for input in traceeInputs {
+      _TFCOpAddInputFromTensorHandle(op, input, status)
+      checkOk(status)
+    }
+
+    debugLog("Adding \(additionalInputTensorCount) additional input tensors.")
+    for i in 0..<additionalInputTensorCount {
+      let input = TFE_ConsumeInputConcreteTensorFromTraceContext(cTraceContext,
+                                                                 UInt32(i))
+      internalConsistencyCheck(input != nil)
+      debugLog("""
+                 Adding additional input tensor of idx \
+                 \(traceeInputs.count+Int(additionalInputTensorCount)):\
+                 \(input!).
+                 """)
+      TFE_OpAddInput(op, input, status)
+      checkOk(status)
+    }
+
+    // Tell TensorFlow to execute the graph function we built, containing
+    // the trace.
+    let maxReturnValueCount = tracedOutputs.count
+    debugLog("""
+               Executing trace func \(tracedFunctionName!) with up to \
+               \(maxReturnValueCount) return values.
+               """)
+    var returnValues = [CTensorHandle?](repeating: nil,
+                                        count: maxReturnValueCount)
+    var outputReturnValueCount = Int32(maxReturnValueCount)
+    TFE_Execute(op, &returnValues, &outputReturnValueCount, status)
+    checkOk(status)
+    debugLog("""
+               returnValues.count=\(returnValues.count), \
+               outputReturnValueCount=\(outputReturnValueCount).
+               """)
+    internalConsistencyCheck(outputReturnValueCount <= returnValues.count)
+
+    // Now that all the output elements have been filled in, remove a level of
+    // optional, and also add concrete outputs.
+    var traceGraphOutputs: [CTensorHandle] = []
+    // Points to an element in `returnValues`.
+    var returnValueIdx = 0
+    // See the comment block within finalize() below on why we handle concrete
+    // and symbolic output tensors differently.
+    for tracedOutput in tracedOutputs {
+      if TFE_TensorHandleIsConcrete(tracedOutput) != 0 {
+        // These concrete tensors are owned by some other objects, so we make a
+        // copy here.
+        let newOutput = TFE_TensorHandleCopySharingTensor(tracedOutput, status)
+        checkOk(status)
+        internalConsistencyCheck(newOutput != nil)
+        traceGraphOutputs.append(newOutput!)
+      } else {
+        // These symbolic tensors are produced by TFE_Execute() above, and we
+        // need not make an extra copy.
+        internalConsistencyCheck(returnValues[returnValueIdx] != nil)
+        traceGraphOutputs.append(returnValues[returnValueIdx]!)
+        returnValueIdx += 1
+      }
+    }
+    internalConsistencyCheck(returnValueIdx == outputReturnValueCount)
+    return traceGraphOutputs
+  }
+
+  /// Bind data to the inputs of the graph and return the specialized graph.
+  func specializeTFFunction(with dataTensors: [CTensorHandle]) -> String {
+    let specializedGraph = TF_NewGraph()!
+
+    TF_GraphCopyFunction(
+      specializedGraph, traceGraphFn, /*gradient*/ nil, status)
+    checkOk(status)
+
+    let tracedFunctionName = TF_FunctionName(traceGraphFn)
+    internalConsistencyCheck(tracedFunctionName != nil)
+    let tracedOpDesc = TF_NewOperation(
+      specializedGraph, tracedFunctionName, "tracedFn")
+
+    // Create and append the inputs to the graph function.
+    let traceeInputs = symbolicInputs.dropLast(
+      dataTensors.count + Int(additionalInputTensorCount))
+    var inputs: [TF_Output] = []
+    for (i, traceeInput) in traceeInputs.enumerated() {
+      let desc = TF_NewOperation(specializedGraph, "Placeholder", "input_\(i)")
+      TF_SetAttrType(desc, "dtype", TF_OperationOutputType(traceeInput))
+      let result = TF_FinishOperation(desc, status)
+      checkOk(status)
+      let input = TF_Output(oper: result, index: 0)
+      TF_AddInput(tracedOpDesc, input)
+      inputs.append(input)
+    }
+
+    // Wire the data to the corresponding inputs of the tracedOp.
+    for (i, cTensorHandle) in dataTensors.enumerated() {
+      let cTensor = TFE_TensorHandleResolve(cTensorHandle, status)
+      checkOk(status)
+      let desc = TF_NewOperation(specializedGraph, "Const", "input_const_\(i)")
+      TF_SetAttrType(desc, "dtype", TFE_TensorHandleDataType(cTensorHandle))
+      TF_SetAttrTensor(desc, "value", cTensor, status)
+      checkOk(status)
+      let result = TF_FinishOperation(desc, status)
+      checkOk(status)
+      TF_AddInput(tracedOpDesc, TF_Output(oper: result, index: 0))
+    }
+
+    var nextConst = dataTensors.count
+    debugLog("Adding \(additionalInputTensorCount) additional input tensors.")
+    for i in 0..<additionalInputTensorCount {
+      let cTensorHandle =
+        TFE_ConsumeInputConcreteTensorFromTraceContext(cTraceContext, UInt32(i))
+      internalConsistencyCheck(cTensorHandle != nil)
+      let cTensor = TFE_TensorHandleResolve(cTensorHandle, status)
+      checkOk(status)
+      let desc = TF_NewOperation(
+        specializedGraph, "Const", "input_const_\(nextConst)")
+      nextConst += 1
+      TF_SetAttrType(desc, "dtype", TFE_TensorHandleDataType(cTensorHandle))
+      TF_SetAttrTensor(desc, "value", cTensor, status)
+      checkOk(status)
+      debugLog("""
+                 Adding additional input tensor of idx \
+                 \(traceeInputs.count+Int(additionalInputTensorCount)):\
+                 \(cTensorHandle!).
+                 """)
+      let result = TF_FinishOperation(desc, status)
+      checkOk(status)
+      TF_AddInput(tracedOpDesc, TF_Output(oper: result, index: 0))
+    }
+
+    let tracedOp = TF_FinishOperation(tracedOpDesc, status)
+    checkOk(status)
+
+    // Set up outputs.
+    var outputIndex: Int32 = 0
+    var outputs: [TF_Output] = []
+    // Get the symbolic outputs from the output.
+    for output in tracedOutputs
+      where TFE_TensorHandleIsConcrete(output) == 0 {
+      outputs.append(TF_Output(oper: tracedOp, index: outputIndex))
+      outputIndex += 1
+    }
+    // Create constants for the concrete outputs.
+    for output in tracedOutputs
+      where TFE_TensorHandleIsConcrete(output) != 0 {
+      let cTensor = TFE_TensorHandleResolve(output, status)
+      checkOk(status)
+      let desc = TF_NewOperation(
+        specializedGraph, "Const", "output_const_\(outputIndex)")
+      TF_SetAttrType(desc, "dtype", TFE_TensorHandleDataType(output))
+      TF_SetAttrTensor(desc, "value", cTensor, status);
+      checkOk(status)
+      let result = TF_FinishOperation(desc, status)
+      checkOk(status)
+      outputs.append(TF_Output(oper: result, index: outputIndex))
+      outputIndex += 1
+    }
+    let specializedTFFuncName =
+      "specialized_tffunc_\(_RuntimeConfig.traceGraphFunctionCounter)"
+    _RuntimeConfig.traceGraphFunctionCounter += 1
+
+    let tffunc =
+      TF_GraphToFunction(specializedGraph, specializedTFFuncName,
+                         /*append_hash_to_fn_name*/ 0,
+                         /*num_opers*/ -1,
+                         /*opers*/ nil,
+                         /*numinputs*/ Int32(inputs.count),
+                         /*inputs*/ inputs,
+                         /*noutputs*/ Int32(outputs.count),
+                         /*outputs*/ outputs,
+                         /*outputnames*/ nil,
+                         /*functionoptions*/ nil, "", status)
+    checkOk(status)
+
+    if _RuntimeConfig.printsDebugLog {
+      var len: Int = 0
+      let funcDebugStr = TF_FunctionDebugString(tffunc, &len)!
+      debugLog("Specialized TF_Function is:\n\(String(cString: funcDebugStr))")
+      free(funcDebugStr)
+    }
+    let eagerContext = _TFCGetGlobalEagerContext()
+    TFE_ContextAddFunction(eagerContext, tffunc, status)
+    checkOk(status)
+    return specializedTFFuncName
+  }
+}
+
+// This enum keeps track of whether we are building or executing a trace.
+@usableFromInline
+internal enum TracingState {
+  case notTracing
+  case tracing(TraceContext)
+
+  // Return nil if we are not in tracing mode.
+  @usableFromInline
+  var context: TraceContext? {
+    guard case let .tracing(context) = self else { return nil }
+    return context
+  }
+}
+
+/// The configuration for the compiler runtime.
+// TODO(hongm): Revisit the longer-term design.
+// @_frozen // SR-9739
+public enum _RuntimeConfig {
+  // TODO: change this and subsequent properties from static to thread local.
+  @usableFromInline
+  internal static var traceState: TracingState = .notTracing
+
+  /// Used to create unique trace graph function names.
+  fileprivate static var traceGraphFunctionCounter = 0
+
+  /// When false, tensorflow runtime will be initialized before running any
+  /// tensor program in this process.
+  static public var tensorFlowRuntimeInitialized = false
+
+  /// When true, run the entire tensor computation in
+  /// _TFCStartTensorComputation(), instead of running it on a separate thread.
+  /// - Note: Set to true only for debugging purposes, as it has limited
+  ///   functionality (e.g. no sends/recvs support).
+  static public var usesSynchronousExecution = false
+
+  /// For CPU and GPU execution without XLA, use the auto mode. For XLA and/or
+  /// TPU execution, set the enum value accordingly.
+  static public var executionMode: _ExecutionMode = .auto
+
+  /// When true, let TensorFlow GPU memory allocation start small and grow as
+  /// needed. Otherwise, The entire GPU memory region is pre-allocated.
+  static public var gpuMemoryAllowGrowth = true
+
+  /// The number of CPU devices.
+  static public var cpuDeviceCount: UInt32 = 1
+
+  /// When non-nil, run metadata (with full trace) of each session execution
+  /// will be dumped to the give path.
+  static public var runMetadataOutputPath: String? = nil
+
+  /// Specifies whether the TensorFlow computation runs in a local (in-process)
+  /// session, or a remote session with the specified server definition.
+  // @_frozen // SR-9739
+  public enum RuntimeSession {
+    case local
+    case remote(serverDef: String)
+  }
+  static public var session: RuntimeSession = .local
+
+  /// When true, prints various debug messages on the runtime state.
+  ///
+  /// If the value is true when running tensor computation for the first time in
+  /// the process, INFO log from TensorFlow will also get printed.
+  static public var printsDebugLog = false
+
+  /// Specifies the verbose log level in TensorFlow; a higher level prints out
+  /// more log. Only meaningful when `printsDebugLog` is true, and must be
+  /// within [0, 4] in that case.
+  static public var tensorflowVerboseLogLevel: Int32 = 0 {
+    willSet {
+      debugLog("About to set tensorflowVerboseLogLevel to \(newValue)")
+      guard newValue >= 0 && newValue <= 4 else {
+        fatalError("Invalid tensorflowVerboseLogLevel value \(newValue)")
+      }
+    }
+  }
+}
+
+private func configureRuntimeFromEnvironment() {
+  if let value = getenv("SWIFT_TENSORFLOW_ENABLE_DEBUG_LOGGING"),
+    String(cString: value).lowercased() == "true" {
+      _RuntimeConfig.printsDebugLog = true
+      debugLog("Turning on debug logging from env.")
+  }
+
+  if let value = getenv("SWIFT_TENSORFLOW_VERBOSE_LOG_LEVEL") {
+    guard var verboseLevel = Int32(String(cString: value)) else {
+      fatalError("SWIFT_TENSORFLOW_VERBOSE_LOG_LEVEL must take an int value.")
+    }
+    if verboseLevel > 4 {
+      verboseLevel = 4
+    }
+    _RuntimeConfig.tensorflowVerboseLogLevel = verboseLevel
+    debugLog("Setting TF logging verbose level to \(verboseLevel) from env.")
+  }
+
+  if let value = getenv("SWIFT_TENSORFLOW_USE_TPU_INFEED"),
+    String(cString: value).lowercased() == "true" {
+      _RuntimeConfig.executionMode = .tpu
+      debugLog("Setting TPU execution with infeed from env.")
+  }
+
+  if let value = getenv("SWIFT_TENSORFLOW_SYNC_EXECUTION"),
+    String(cString: value).lowercased() == "true" {
+      _RuntimeConfig.usesSynchronousExecution = true
+      debugLog("Using sync execution from env.")
+  }
+
+  if let value = getenv("SWIFT_TENSORFLOW_SERVER_ADDRESS") {
+    let address = String(cString: value)
+    debugLog("Env var SWIFT_TENSORFLOW_SERVER_ADDRESS has value \(address).")
+    if address == "local" {
+      _RuntimeConfig.session = .local
+      debugLog("Using local TF session.")
+    } else {
+      guard let idx = address.firstIndex(of: ":"),
+         let endIdx = address.index(idx, offsetBy: 3, limitedBy: address.endIndex),
+         address[idx..<endIdx] == "://" else {
+        fatalError("SWIFT_TENSORFLOW_SERVER_ADDRESS must start with 'grpc://'.")
+      }
+
+      let `protocol` = address[address.startIndex..<idx]
+      let target = address[endIdx..<address.endIndex]
+      _RuntimeConfig.session = .remote(serverDef: """
+        cluster {
+          job {
+            name: "localhost"
+            tasks {
+              key: 0
+              value: "127.0.0.1:0"
+            }
+            tasks {
+              key: 1
+              value: "\(target)"
+            }
+          }
+        }
+        job_name: "localhost"
+        task_index: 0
+        protocol: "\(`protocol`)"
+        """)
+      debugLog("Setting TF server address to \(address) from env.")
+    }
+  }
+
+  if let value = getenv("SWIFT_TENSORFLOW_RUN_METADATA_OUTPUT") {
+    let path = String(cString: value)
+    _RuntimeConfig.runMetadataOutputPath = path
+    debugLog("Setting run metadata output path to \(path) from env.")
+  }
+
+  if let value = getenv("SWIFT_TENSORFLOW_CPU_DEVICE_COUNT") {
+    guard let cpuDeviceCount = UInt32(String(cString: value)) else {
+      fatalError("SWIFT_TENSORFLOW_CPU_DEVICE_COUNT must take an int value.")
+    }
+    _RuntimeConfig.cpuDeviceCount = cpuDeviceCount
+    debugLog("Setting number of CPU devices to \(cpuDeviceCount) from env.")
+  }
+}
+
+/// Initialize the TPU system.
+/// - Note: This should be called only once.
+/// - Precondition: The given session must contain the given graph.
+// TODO(b/77572335): Reassess how to reset TPU after execution error.
+private func initializeTPU(withSession session: CTFSession, graph: CTFGraph,
+                           status: CTFStatus) {
+  debugLog("Initializing TPU.")
+  let configOp = TF_GraphOperationByName(graph, "ConfigureDistributedTPU")
+  internalConsistencyCheck(configOp != nil)
+  var configNode = TF_Output(oper: configOp, index: 0)
+  var dummyOutput: CTensor?
+  TF_SessionRun(session, nil, nil, nil, 0, &configNode, &dummyOutput, 1, nil,
+                0, nil, status)
+  checkOk(status)
+  TF_DeleteTensor(dummyOutput)
+}
+
+/// The host of any tensor computation.
+@_fixed_layout
+public final class _ExecutionContext {
+  /// Global context storing all available devices, loaded functions, etc.
+  public static let global: _ExecutionContext = _ExecutionContext()
+
+  // TODO: When we use remote session, we need to set cpu device to a local
+  // device.  There is no C API yet to find the local device. So, we are
+  // hard-coding the value for now.
+  fileprivate let cpuDeviceNamePrefix = "/job:localhost/replica:0/task:0/device:CPU:"
+
+  /// Only set when there is some usable GPU.
+  fileprivate let gpuDeviceNamePrefix: String?
+
+  /// Only set when there is some usable TPU.
+  fileprivate let tpuDeviceNamePrefix: String?
+
+  /// The buffer storing a serialized TensorFlow config proto.
+  public let tensorFlowConfig: UnsafeMutablePointer<TF_Buffer>
+
+  /// The TFE_Context object.
+  public let eagerContext: CTFEContext
+
+  // NOTE: the following properties are intentionally not implemented as an enum
+  // due to high churn, *please do not refactor for Swiftiness*.
+  /// The set of all loaded programs indexed by their unique address.
+  private var loadedPrograms: [UnsafeRawPointer : CTFGraph] = [:]
+
+  /// The status for checking TensorFlow errors.
+  private let status: CTFStatus = TF_NewStatus()
+
+  /// The mutex for preventing potential concurrent access.
+  private var mutex: pthread_mutex_t = pthread_mutex_t()
+
+  /// Initializes a new execution context by initializing available devices.
+  @usableFromInline
+  init() {
+    configureRuntimeFromEnvironment()
+
+    // Suppress TensorFlow logging, unless the user specified a log level.
+    setenv("TF_CPP_MIN_LOG_LEVEL", "3", /*override*/ 0)
+
+    debugLog("Initializing global context.")
+
+    // Initialize the TF runtime exactly once. Only affects local execution
+    // (when _RuntimeConfig.tensorFlowServer is set to "").
+    if !_RuntimeConfig.tensorFlowRuntimeInitialized {
+      InitTensorFlowRuntime(_RuntimeConfig.printsDebugLog ? 1 : 0,
+                            _RuntimeConfig.tensorflowVerboseLogLevel)
+      _RuntimeConfig.tensorFlowRuntimeInitialized = true
+    }
+
+    guard let opts = TFE_NewContextOptions() else {
+      fatalError("ContextOptions object can never be nil.")
+    }
+
+    // Create TF config object.
+    if _RuntimeConfig.executionMode == .xla {
+      debugLog("Enable XLA execution.")
+    }
+    if _RuntimeConfig.gpuMemoryAllowGrowth {
+      debugLog("Allowing growth for GPU memory allocator.")
+    }
+    self.tensorFlowConfig = TF_CreateConfig(
+      _RuntimeConfig.executionMode == .xla ? 1 : 0,
+      _RuntimeConfig.gpuMemoryAllowGrowth ? 1 : 0,
+      _RuntimeConfig.cpuDeviceCount)
+    TFE_ContextOptionsSetConfig(opts,
+                                tensorFlowConfig.pointee.data,
+                                tensorFlowConfig.pointee.length,
+                                status)
+    checkOk(status)
+
+    let ctx = TFE_NewContext(opts, status)
+    checkOk(status)
+    self.eagerContext = ctx!
+    TFE_DeleteContextOptions(opts)
+    checkOk(status)
+
+    if case .remote(let serverDef) = _RuntimeConfig.session {
+      debugLog("Setting up the server def to \(serverDef)...")
+      let serverDef: UnsafeMutablePointer! =
+        TFE_GetServerDef(serverDef, status)
+      checkOk(status)
+      TFE_ContextSetServerDef(eagerContext, /*keep_alive_secs*/0,
+        serverDef.pointee.data, serverDef.pointee.length, status)
+      checkOk(status)
+      TF_DeleteBuffer(serverDef)
+    }
+
+    // Initialize GPU device.
+    // While the code here is only needed when _RuntimeConfig.executionMode is
+    // set to .gpu, running it in all code paths helps keep things simple
+    // (e.g. so that the cpuDeviceNamePrefix property is always set.)
+    let devices = TFE_ContextListDevices(eagerContext, status)
+    checkOk(status)
+    defer { TF_DeleteDeviceList(devices!) }
+
+    // Sanity check and gather/log device info. When `gpuCount` > 0, set
+    // `self.gpuDeviceNamePrefix`. Likewise with `tpuCount`.
+    let deviceCount = TF_DeviceListCount(devices!)
+    debugLog("There are \(deviceCount) devices.")
+    var foundCPU = false
+    var gpuCount = 0
+    var tpuCount = 0
+    for deviceId in 0..<deviceCount {
+      let cDeviceName = TF_DeviceListName(devices, deviceId, status)
+      checkOk(status)
+      let deviceName = String(cString: cDeviceName!)
+      let cDeviceType = TF_DeviceListType(devices, deviceId, status)
+      checkOk(status)
+      let deviceType = String(cString: cDeviceType!)
+      debugLog(
+        "Device \(deviceId) has type \(deviceType) and name \(deviceName)."
+      )
+      if deviceType == "CPU", deviceName.starts(with: cpuDeviceNamePrefix) {
+        foundCPU = true
+      }
+      if deviceType == "GPU" {
+        gpuCount += 1
+      }
+      if deviceType == "TPU" {
+        tpuCount += 1
+      }
+    }
+    guard foundCPU else {
+      fatalError("CPU should always be an available device.")
+    }
+    // We ignore the number of GPUs for now. It might be useful to cross check
+    // that against the number of GPUs that user intends to use (e.g. via the
+    // `withDevice` syntax).
+    if gpuCount > 0 {
+      self.gpuDeviceNamePrefix = "/job:localhost/replica:0/task:0/device:GPU:"
+    } else {
+      self.gpuDeviceNamePrefix = nil
+    }
+
+    if tpuCount > 0 {
+      // According to server def generated when you set
+      // SWIFT_TENSORFLOW_SERVER_ADDRESS, the TPUs will all be on task 1.
+      self.tpuDeviceNamePrefix = "/job:localhost/replica:0/task:1/device:TPU:"
+    } else {
+      self.tpuDeviceNamePrefix = nil
+    }
+
+    // Initialize the mutex.
+    pthread_mutex_init(&mutex, nil)
+  }
+
+  deinit {
+    debugLog("De-initializing global context.")
+    // Delete all loaded programs.
+    TFE_DeleteContext(eagerContext)
+    TF_DeleteBuffer(tensorFlowConfig)
+    TF_DeleteStatus(status)
+    pthread_mutex_destroy(&mutex)
+  }
+}
+
+// Elements in `outputs` can come from two sources:
+// a) Symbolic tensors produced by tensor ops, and added as trace graph nodes.
+// b) Concrete tensors produced by host code (e.g. Tensor(1.0)).
+fileprivate func finalizeTraceFunction(_ name: String) -> TraceContext {
+  guard let traceContext = _RuntimeConfig.traceState.context else {
+    fatalError("Not in tracing mode!.")
+  }
+  _RuntimeConfig.traceState = .notTracing
+  traceContext.finalize(traceeBasicName: name)
+  return traceContext
+}
+
+private extension TensorArrayProtocol {
+  // The returned handles are owned by the caller.
+  var cTensorHandles: [CTensorHandle] {
+    debugLog("Getting \(self._tensorHandleCount) C handles.")
+    let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(
+      capacity: Int(self._tensorHandleCount))
+    debugLog("Unpacking handles into buffer.")
+    _unpackTensorHandles(into: buffer)
+    let status = TF_NewStatus()
+    debugLog("Copying buffer content to output handles.")
+    var output: [CTensorHandle] = []
+    for i in 0..<Int(_tensorHandleCount) {
+      let address = buffer.advanced(by: i)
+      let isConcrete = TFE_TensorHandleIsConcrete(address.pointee) != 0
+      debugLog("""
+                 Copying the \(i)-th C handle \(address.pointee) with \
+                 concrete=\(isConcrete).
+                 """)
+      let newHandle = TFE_TensorHandleCopySharingTensor(address.pointee,
+                                                        status)
+      checkOk(status)
+      internalConsistencyCheck(newHandle != nil)
+      debugLog("""
+                 Copying the \(i)-th C handle \(address.pointee) with \
+                 concrete=\(isConcrete) to C handle create \(newHandle!).
+                 """)
+      output.append(newHandle!)
+    }
+    TF_DeleteStatus(status)
+    return output
+  }
+}
+
+private extension TensorGroup {
+  // The tensors in `input` are NOT owned by this instance.
+  init<C: Collection>(_copying input: C) where C.Element == CTensorHandle {
+    assert(Self._tensorHandleCount == input.count)
+    let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(
+      capacity: input.count)
+    let status = TF_NewStatus()
+    // copy input to buffer
+    for (i, inputTensorHandle) in input.enumerated() {
+      let address = buffer.advanced(by: i)
+      // Each tensor can be symbolic (e.g. when using this API to create a
+      // symbolic input instance to tracee) or concrete (e.g. when creating the
+      // final output of the tracee).
+      let newHandle = TFE_TensorHandleCopySharingTensor(inputTensorHandle,
+                                                        status)
+      checkOk(status)
+      address.initialize(to: newHandle!)
+    }
+    TF_DeleteStatus(status)
+    self.init(_owning: buffer)
+  }
+
+  init<C: Collection>(_owning input: C) where C.Element == CTensorHandle {
+    assert(Self._tensorHandleCount == input.count)
+    let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(
+      capacity: input.count)
+    let status = TF_NewStatus()
+    // copy input to buffer
+    for (i, inputTensorHandle) in input.enumerated() {
+      let address = buffer.advanced(by: i)
+      address.initialize(to: inputTensorHandle)
+    }
+    TF_DeleteStatus(status)
+    self.init(_owning: buffer)
+  }
+}
+
+// TODO: Fold this protocol into TensorArrayProtocol.
+// This requires that we move concrete implementation such as
+// Tensor._makeInstance() to TensorGroup.swift.
+public protocol _TensorArrayProtocolEnhanced : TensorArrayProtocol {
+  // Create an instance based on `inputs`, which can be symbolic (e.g. when
+  // creating a symbolic input to tracee) or concrete (e.g. when creating a
+  // final output of executing the tracee).
+  func _makeInstance<C: Collection>(owning inputs: C) -> Self
+    where C.Element == CTensorHandle
+}
+
+
+extension _TensorArrayProtocolEnhanced {
+  var _dtypes: [TF_DataType] {
+    let count = Int(_tensorHandleCount)
+    let buffer =
+        UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: count)
+    defer { buffer.deallocate() }
+    _unpackTensorHandles(into: buffer.baseAddress)
+    return buffer.map { TFE_TensorHandleDataType($0) }
+  }
+}
+
+/// Trace `fn` with newly created tensor handles and return a trace context.
+private func _trace(
+  with dtypes: [TF_DataType],
+  in fn: ([CTensorHandle]) -> [CTensorHandle]
+) -> TraceContext {
+  debugLog("""
+             Tracing over a function with \(dtypes.count) inputs.
+             """)
+
+  // Verify that we are not already tracing.
+  internalConsistencyCheck(_RuntimeConfig.traceState.context == nil,
+                           "Should not be in tracing mode already!")
+
+  // Switch to tracing mode.
+  let traceCtx = TraceContext(dtypes: dtypes)
+  _RuntimeConfig.traceState = .tracing(traceCtx)
+
+  // Handle inputs.
+  let inputSymbolicTensors = traceCtx.symbolicInputs.map {
+    TFE_NewTensorHandleFromTFOutput($0, TF_OperationOutputType($0))!
+  }
+  internalConsistencyCheck(inputSymbolicTensors.count == dtypes.count)
+
+  // Run tracee to build the trace, adding ops to the trace graph function.
+  // The tracee output can contain a mixture of symbolic and concrete tensors
+  // (see the comment block within TraceContext.finalize()).
+   debugLog("Running tracee in tracing mode.")
+  traceCtx.tracedOutputs = fn(inputSymbolicTensors)
+
+  debugLog("Finalizing trace graph function.")
+  // TAP means tensor array protocol.
+  let opType = "MyTraceFn_TAP"
+  return finalizeTraceFunction(opType)
+}
+
+private func _graphInternal<State : _TensorArrayProtocolEnhanced,
+                            Data : TensorGroup,
+                            Result : TensorGroup>(
+  with state: State,
+  in fn: (State, Data) -> (State, Result?)
+) -> (State, Data) -> (State, Result?) {
+  let traceContext: TraceContext = withoutActuallyEscaping(fn) { escapableFn in
+    let wrappedFn = { (inputs: [CTensorHandle]) -> [CTensorHandle] in
+      let symbolicState = state._makeInstance(
+        owning: inputs.dropLast(Data._typeList.count))
+      let symbolicData = Data(
+        _copying: inputs.dropFirst(Int(state._tensorHandleCount)))
+      let (outputState, outputResult) = escapableFn(symbolicState, symbolicData)
+
+      debugLog("Assembling output tensor handles.")
+      let outputs =
+        outputResult != nil
+          ? (outputState.cTensorHandles + outputResult!.cTensorHandles)
+          : outputState.cTensorHandles
+      return outputs
+    }
+    let dtypes = state._dtypes + Data._typeList.map { $0._cDataType }
+    return _trace(with: dtypes, in: wrappedFn)
+  }
+  // The result is a closure that captures and executes the trace graph
+  // function in the trace context.
+  return { (oldState: State, data: Data) -> (State, Result?) in
+    debugLog("Running trace function over state \(oldState) and data \(data).")
+
+    debugLog("Getting input state tensor handles.")
+    let inputStateTensorHandles =  oldState.cTensorHandles
+    var inputTensors = inputStateTensorHandles.map {
+      _TFCCreateTensorHandleFromC($0)
+    }
+    debugLog("Getting input data tensor handles.")
+    let inputDataTensorHandles =  data.cTensorHandles
+    inputTensors.append(contentsOf: inputDataTensorHandles.map {
+      _TFCCreateTensorHandleFromC($0)
+    })
+
+    debugLog("Executing trace graph function.")
+    let returnValues = traceContext.execute(traceeInputs: inputTensors)
+
+    debugLog("Creating output model instance.")
+    let newState = state._makeInstance(owning: returnValues.prefix(
+                                         Int(state._tensorHandleCount)))
+    let resultValues = returnValues.dropFirst(Int(state._tensorHandleCount))
+    let result: Result? = resultValues.isEmpty ? nil : Result(_owning: resultValues)
+    return (newState, result)
+  }
+}
+
+// TODO: rename this to `graph` when it's ready for end users.
+public func _graph<State : _TensorArrayProtocolEnhanced,
+                   Data : TensorGroup,
+                   Result : TensorGroup>(
+  with state: State,
+  in fn: (State, Data) -> (State, Result)
+) -> (State, Data) -> (State, Result) {
+  let graphFunction = _graphInternal(with: state, in: fn)
+  return { (state: State, data: Data) in
+    let result = graphFunction(state, data)
+    internalConsistencyCheck(result.1 != nil)
+    return (result.0, result.1!)
+  }
+}
+
+// TODO: rename this to `graph` when it's ready for end users.
+public func _graph<State : _TensorArrayProtocolEnhanced, Data : TensorGroup>(
+  with state: State,
+  in fn: (State, Data) -> State
+) -> (State, Data) -> State {
+  let graphFunction: (State, Data) -> (State, TensorHandle<Float>?) =
+    withoutActuallyEscaping(fn) { escapableFn in
+      let wrappedFn = {
+        // The result argument needs to a type that conforms to TensorGroup.
+        // We are arbitrarily picking TensorHandle<Float> here.
+        (s: State, d: Data) -> (State, TensorHandle<Float>?) in
+          (escapableFn(s, d), nil)
+      }
+      return _graphInternal(with: state, in: wrappedFn)
+    }
+  return { (state: State, data: Data) in graphFunction(state, data).0 }
+}
+
+/// Trace the given function `fn` and return a closure that can be used to
+/// create a `TF_Function(State)` specialized for `data`.
+public func _tffunc<State : _TensorArrayProtocolEnhanced,
+                    Data : TensorGroup>(
+  with state: State,
+  in fn: (State, Data) -> State
+) -> (Data) -> (String) {
+  let traceContext: TraceContext = withoutActuallyEscaping(fn) { escapableFn in
+    let wrappedFn = { (inputs: [CTensorHandle]) -> [CTensorHandle] in
+      let symbolicState = state._makeInstance(
+        owning: inputs.dropLast(Data._typeList.count))
+      let symbolicData = Data(
+        _copying: inputs.dropFirst(Int(state._tensorHandleCount)))
+      let outputState = escapableFn(symbolicState, symbolicData)
+      return outputState.cTensorHandles
+    }
+    let dtypes = state._dtypes + Data._typeList.map { $0._cDataType }
+    return _trace(with: dtypes, in: wrappedFn)
+  }
+  return {
+    data in traceContext.specializeTFFunction(with: data.cTensorHandles)
+  }
+}
+
+// Trace the given function to generate a TF graph and return a closure
+// that can be used to launch the graph.
+public func _graph<In : TensorGroup, Out : TensorGroup>(
+  _ fn: (In) -> Out, useXLA: Bool = false
+) -> (In) -> Out {
+  let traceContext: TraceContext = withoutActuallyEscaping(fn) { escapableFn in
+    let wrappedFn = { (inputs: [CTensorHandle]) -> [CTensorHandle] in
+      let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(
+        capacity: Int(inputs.count))
+      var ptr = buffer
+      for input in inputs {
+        ptr.initialize(to: input)
+        ptr = ptr.advanced(by: 1)
+      }
+      let symbolicIn = In(_owning: buffer)
+      let symbolicOut = escapableFn(symbolicIn)
+      return symbolicOut.cTensorHandles
+    }
+    let dtypes = In._typeList.map { $0._cDataType }
+    return _trace(with: dtypes, in: wrappedFn)
+  }
+  // The result is a closure that captures and executes the trace graph
+  // function in the trace context.
+  return { (input: In) -> (Out) in
+    debugLog("Running trace function over input \(input).")
+
+    debugLog("Getting input state tensor handles.")
+    let inputStateTensorHandles =  input.cTensorHandles
+    let inputTensors = inputStateTensorHandles.map {
+      _TFCCreateTensorHandleFromC($0)
+    }
+    debugLog("Executing trace graph function.")
+    let returnValues = traceContext.execute(
+      traceeInputs: inputTensors, useXLA: useXLA)
+
+    debugLog("Creating output model instance.")
+    return Out(_owning: returnValues)
+  }
+}
+
+/// Trace the given function and return the name of the corresponding
+/// `TF_Function: In -> Out` that was created.
+public func _tffunc<In : TensorGroup, Out : TensorGroup>(
+  _ fn: (In) -> Out
+) -> String {
+  let traceContext: TraceContext = withoutActuallyEscaping(fn) { escapableFn in
+    let wrappedFn = {
+      (inputs: [CTensorHandle]) -> [CTensorHandle] in
+      let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(
+        capacity: Int(inputs.count))
+      var ptr = buffer
+      for input in inputs {
+        ptr.initialize(to: input)
+        ptr = ptr.advanced(by: 1)
+      }
+      let symbolicIn = In(_owning: buffer)
+      let symbolicOut = escapableFn(symbolicIn)
+      return symbolicOut.cTensorHandles
+    }
+    
+    let dtypes = In._typeList.map { $0._cDataType }
+    return _trace(with: dtypes, in: wrappedFn)
+  }
+  return traceContext.specializeTFFunction(with: [])
+}
+
+/// Returns a valid TF device string such as
+/// "/job:localhost/replica:0/task:0/device:CPU:0", which corresponds to the
+/// closest enclosing withDevice() construct.
+/// A return value of nil indicates the absence of withDevice().
+internal extension _ExecutionContext {
+  @usableFromInline
+  var currentDeviceName: String? {
+    if let (kind, index) = _ThreadLocalState.value._currentDevice {
+      switch kind {
+      case .cpu:
+        return "\(cpuDeviceNamePrefix)\(index)"
+      case .gpu:
+        return "\(gpuDeviceNamePrefix!)\(index)"
+      case .tpu:
+        return "\(tpuDeviceNamePrefix!)\(index)"
+      }
+    }
+    return nil
+  }
+}
+
+internal extension _ExecutionContext {
+  /// Synchronously execute the body, preventing asynchronous computation from
+  /// corrupting the context data.
+  private func sync<Result>(
+    execute body: () throws -> Result
+  ) rethrows -> Result {
+    let lockStatus = pthread_mutex_lock(&mutex)
+    internalConsistencyCheck(lockStatus == 0)
+    defer {
+      let unlockStatus = pthread_mutex_unlock(&mutex)
+      internalConsistencyCheck(unlockStatus == 0)
+      // Create a cancellation point.
+      pthread_testcancel()
+    }
+    return try body()
+  }
+}
+
+fileprivate extension _ExecutionContext {
+  /// Load the graph functions of a serialized TensorFlow GraphDef binary proto
+  /// into the context, if that has not been done yet. Return the graph.
+  /// - Parameters:
+  ///   - address: The address of the serialized program in memory.
+  ///   - count: The size of the program in bytes.
+  func loadProgramInBytes(_ address: UnsafeRawPointer, count: Int) -> CTFGraph {
+    return sync {
+      debugLog("Loading a program.")
+       // If the program is already loaded, do nothing.
+      if let graph = loadedPrograms[address] {
+        return graph
+      }
+      // Here we have to do a fairly awkward dance to load the graph functions
+      // and populate them into the TFE_Context.  We load the program as a
+      // TF_Graph, then copy the functions out of it, then copy them into the
+      // TFE_Context.
+      debugLog("Loading graph functions.")
+      let graph = TF_NewGraph()!
+      // TensorFlow loads things through TF_Buffer.  Create one that avoids
+      // redundantly copying the program bytes.
+      var programBuf = TF_Buffer(data: address, length: count,
+                                 data_deallocator: nil)
+      let graphDefOptions = TF_NewImportGraphDefOptions()
+      TF_GraphImportGraphDef(graph, &programBuf, graphDefOptions, self.status)
+      TF_DeleteImportGraphDefOptions(graphDefOptions)
+      checkOk(self.status)
+      // Now that we have all of the TF_Function objects in the graph, copy them
+      // to standalone TF_Function's.
+      let funcCount = TF_GraphNumFunctions(graph)
+      // Allocate an array to accept functions.
+      var funcs: [CTFFunction?] = Array(repeating: nil, count: Int(funcCount))
+      TF_GraphGetFunctions(graph, &funcs, funcCount, self.status)
+      checkOk(self.status)
+
+      // Add functions to the context.
+      debugLog("Adding \(funcCount) functions to context.")
+      for function in UnsafeBufferPointer(start: funcs, count: Int(funcCount)) {
+        TFE_ContextAddFunction(self.eagerContext, function, self.status)
+        checkOk(self.status)
+        debugLog("Added func \(String(cString: TF_FunctionName(function))).")
+        TF_DeleteFunction(function)
+      }
+
+       // Memorize the loaded program by address.
+      loadedPrograms[address] = graph
+      debugLog("Done loading a new program.")
+      return graph
+    }
+  }
+}
+
+public extension _ExecutionContext {
+  /// Load functions from a graph encoded as a byte-pointer and length into the
+  /// tensorflow eagerContext.
+  func loadFunctionsFromGraph(byteAddress: UnsafeRawPointer, byteCount: Int) {
+    _ = loadProgramInBytes(byteAddress, count: byteCount)
+  }
+}
+
+@usableFromInline
+internal func dumpTensorContent<Scalar : _TensorFlowDataTypeCompatible>(
+  _ inputTensor: CTensorHandle, _: Scalar.Type
+) {
+  assert(TFE_TensorHandleIsConcrete(inputTensor) != 0)
+
+  let array = ShapedArray<Scalar>(cTensorHandle: inputTensor)
+  debugLog("Rank is \(array.rank), shape is \(array.shape).")
+  debugLog("""
+    The content of the \(array.scalars.count) scalars are: \
+    \(array.scalars).
+    """)
+}
+
+@usableFromInline
+internal func dumpCTensorHandleContent(
+  _ idx: Int,
+  _ inputTensorHandle: CTensorHandle) {
+  if TFE_TensorHandleIsConcrete(inputTensorHandle) == 0 {
+    debugLog("Skip dumpping a symbolic tensor handle.")
+    return
+  }
+
+  let dType: TF_DataType = TFE_TensorHandleDataType(inputTensorHandle)
+  debugLog("Tensor \(idx) has TF data type \(dType).")
+  switch dType {
+  case TF_UINT8: dumpTensorContent(inputTensorHandle, UInt8.self)
+  case TF_INT8: dumpTensorContent(inputTensorHandle, Int8.self)
+  case TF_UINT16: dumpTensorContent(inputTensorHandle, UInt16.self)
+  case TF_INT16: dumpTensorContent(inputTensorHandle, Int16.self)
+  case TF_UINT32: dumpTensorContent(inputTensorHandle, UInt32.self)
+  case TF_INT32: dumpTensorContent(inputTensorHandle, Int32.self)
+  case TF_UINT64: dumpTensorContent(inputTensorHandle, UInt64.self)
+  case TF_INT64: dumpTensorContent(inputTensorHandle, Int64.self)
+  case TF_FLOAT: dumpTensorContent(inputTensorHandle, Float.self)
+  case TF_DOUBLE: dumpTensorContent(inputTensorHandle, Double.self)
+  case TF_BOOL: dumpTensorContent(inputTensorHandle, Bool.self)
+  // TODO: Handle `TF_BFloat16`? BFloat16 does not have a host-side
+  // representation and cannot be printed directly. Consider calling into TF
+  // runtime.
+  default: fatalError("Unsupported dtype \(dType)")
+  }
+}
+
+private class TFEState {
+  let status: CTFStatus = TF_NewStatus()
+  /// The set of graph functions to be concurrently executed (as TFE ops).
+  ///
+  /// The first one is on the primary device, handling input and output
+  /// tensors. The other ones are helper functions that are executed only for
+  /// their side effects (e.g. sending and receiving tensors with the primary
+  /// function).
+  var ops: [CTFEOp] = []
+  init(_ programByteAddress: UnsafeRawPointer,
+       programByteCount: Int,
+       helperFunctionCount: Int,
+       entryFunctionBaseNameAddress: UnsafePointer<Int8>) {
+
+    // Given an input like "foo.tf_13" (prefix if a SIL graph function like
+    // "foo.tf_13_CPU.device_partition"), extract and return "13" as the device
+    // index.
+    func deviceIndexSubstring(from opTypePrefix: Substring) -> Substring {
+      let underscorePos = opTypePrefix.lastIndex(of: "_")
+      internalConsistencyCheck(
+        underscorePos != nil,
+        "Malformed op type prefix \(opTypePrefix)")
+      let startPos = opTypePrefix.index(after: underscorePos!)
+      let deviceIndexStr = opTypePrefix.suffix(from: startPos)
+      return deviceIndexStr
+    }
+
+    let context = _ExecutionContext.global
+    // Make sure the program is loaded into the context.
+    let graph = context.loadProgramInBytes(programByteAddress,
+                                           count: programByteCount)
+
+    let entryFunctionBaseName = String(cString: entryFunctionBaseNameAddress)
+    debugLog("Looking up op(s) from func base name \(entryFunctionBaseName).")
+    for i in 0...helperFunctionCount {
+      // Also look up in the TensorFlow program a function name (op type) based
+      // on the op name. e.g. given op name "tfc_func_S4mainyycfU_.tf", return
+      // op type "S4mainyycfU_.tf_CPU.device_partition". TFE ops are created by
+      // the op types.
+      var opName = "tfc_func_" + entryFunctionBaseName;
+      if i > 0 {
+        opName += "_helper_\(i-1)"
+      }
+      let funcNode = TF_GraphOperationByName(graph, opName)
+      internalConsistencyCheck(
+        funcNode != nil,
+        "Cannot find func node name \(opName)"
+      )
+
+      let opType = String(cString: TF_OperationOpType(funcNode))
+      debugLog("Creating a new op based on type \(opType).")
+      let op: CTFEOp? = TFE_NewOp(context.eagerContext, opType, status)
+      checkOk(status)
+      let deviceName: String?
+      if opType.hasSuffix("_RUNTIME.device_partition") {
+        deviceName = _ExecutionContext.global.currentDeviceName
+      } else if opType.hasSuffix("_CPU.device_partition") {
+        // The op type can be: tmp3_main.tf_17_CPU.device_partition. We want to
+        // extract the device index "17" out of the above name, and use it to
+        // form a TF device string like
+        // "/job:localhost/replica:0/task:0/device:CPU:17".
+        let opTypePrefix = opType.dropLast("_CPU.device_partition".count)
+        let deviceIndexStr = deviceIndexSubstring(from: opTypePrefix)
+        deviceName = context.cpuDeviceNamePrefix + deviceIndexStr
+      } else {
+        // TODO: support TPU as well.
+        internalConsistencyCheck(opType.hasSuffix("_GPU.device_partition"))
+        internalConsistencyCheck(context.gpuDeviceNamePrefix != nil)
+        let opTypePrefix = opType.dropLast("_GPU.device_partition".count)
+        let deviceIndexStr = deviceIndexSubstring(from: opTypePrefix)
+        deviceName = context.gpuDeviceNamePrefix! + deviceIndexStr
+      }
+      if let deviceName = deviceName {
+        debugLog("Placing the op on device \(deviceName).")
+        TFE_OpSetDevice(op, deviceName, status)
+        checkOk(status)
+      } else {
+        debugLog("Not placing the op on any device.")
+      }
+      ops.append(op!)
+    }
+  }
+  deinit {
+    for op in ops {
+      TFE_DeleteOp(op)
+    }
+    TF_DeleteStatus(status)
+  }
+}
+
+extension TFEState {
+  func addInput(_ inputTensorHandle: CTensorHandle) {
+    TFE_OpAddInput(ops[0], inputTensorHandle, status)
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// - MARK: Tensor computation
+//===----------------------------------------------------------------------===//
+
+/// Tensor computation.
+///
+/// - Note: The call sequence for the APIs below must be one of the two:
+///   `init -> terminate()` or `init -> finish()`.
+///   The finish/terminate APIs may only be called once.
+@_fixed_layout
+public final class _TensorComputation {
+  /// The status for checking TensorFlow errors.
+  let status: CTFStatus = TF_NewStatus()
+
+  /// The base name for the set of graph functions to execute in this instance.
+  let entryFunctionBaseName: String
+
+  /// The number of helper functions associated with this TF graph
+  /// execution. For a graph execution over N TF devices, there is a single
+  /// *primary* graph function, responsible for taking input and producing
+  /// output tensors as part of the SessionRun() spec. The other N-1 graph
+  /// functions are *helper* functions, executed together with the primary one
+  /// for their side-effects, such as sending/receiving tensors, "helping" the
+  /// primary function produce the desired output tensors and side effects as
+  /// needed by the SessionRun() call.
+  let helperFunctionCount: Int
+
+  /// The tensor handles returned by the tensor program.
+  // TODO(hongm): Retire returnValues when eager based runtime is removed.
+  var returnValues: [CTensorHandle?]
+
+  private var state: TFEState
+
+  /// The threads to run tensor computation in. In eager mode, we use N threads
+  /// when the tensor computation involves N device functions. In non-eager
+  /// mode, we use a single thread (that's sufficient as these N device
+  /// functions can be sent to the same TF_SessionRun() call.)
+  ///
+  /// The global config flag '_RuntimeConfig.usesSynchronousExecution' decides
+  /// whether tensor computation should be synchronous: if true, this property
+  /// will always be empty. Otherwise, this property is non-empty only when the
+  /// tensor computation is on-going.
+  /// TODO: Remove the `usesSynchronousExecution` mode as it is very limiting
+  /// (e.g. does not support running multiple device functions).
+  private var pthreads: [pthread_t] = []
+
+  /// The data structure to pass into pthread creation API.
+  /// We cannot have the ThreadBody closure below close over on `threadIndex`,
+  /// because ThreadBody is of C convention.
+  private class ThreadParam {
+    let computation: _TensorComputation
+    let threadIndex: Int
+
+    init(computation: _TensorComputation, threadIndex: Int) {
+      self.computation = computation
+      self.threadIndex = threadIndex
+    }
+  }
+
+  /// Loads the TF program from a binary TF FunctionDef proto given by
+  /// 'programByteAddress' and 'programByteCount', and start the computation.
+  ///
+  /// - Parameters:
+  ///   - programByteAddress: The address of the raw program.
+  ///   - programByteCount: The number of bytes in the program.
+  ///   - entryFunctionBaseNameAddress: The base name of the functions to run.
+  ///   - tensorArgumentAddress: The address to the buffer containing tensor
+  ///     arguments as CTensorHandle.
+  ///   - tensorArgumentCount: The number of tensor arguments to pass in.
+  ///   - helperFunctionCount: The number of helper functions to run.
+  ///   - resultCount: The number of output tensors.
+  ///
+  /// - TODO(clattner): `resultCount` should go away when the runtime is
+  ///   implemented with an async design.
+  @usableFromInline
+  init(programByteAddress: UnsafeRawPointer,
+       programByteCount: Int,
+       entryFunctionBaseNameAddress: UnsafePointer<Int8>,
+       tensorArgumentAddress: UnsafePointer<CTensorHandle>,
+       tensorArgumentCount: Int,
+       helperFunctionCount: Int,
+       resultCount: Int) {
+    configureRuntimeFromEnvironment()
+
+    let inputTensorHandles = UnsafeBufferPointer(start: tensorArgumentAddress,
+                                                 count: tensorArgumentCount)
+
+    // Initialize global execution context if that's not yet done. It caches all
+    // our tensor programs.
+    _ = _ExecutionContext.global
+
+    if _RuntimeConfig.printsDebugLog {
+      let buffer = UnsafeBufferPointer(
+        start: programByteAddress.assumingMemoryBound(to: UInt8.self),
+        count: programByteCount)
+      debugLog("The program bytes are \(Array(buffer)).")
+    }
+
+    // Now that we have them in our context, we can get ready to get the top
+    // level function and create an op.
+    self.entryFunctionBaseName = String(cString: entryFunctionBaseNameAddress)
+    debugLog("""
+      Creating a new op with func base name \
+      \(String(cString: entryFunctionBaseNameAddress)).
+      """)
+    self.helperFunctionCount = helperFunctionCount
+    self.state = TFEState(
+        programByteAddress,
+        programByteCount: programByteCount,
+        helperFunctionCount: helperFunctionCount,
+        entryFunctionBaseNameAddress: entryFunctionBaseNameAddress)
+      debugLog("Done initializing TFE-specific state.")
+
+    debugLog("Populating the op's input list.")
+    for (i, inputTensorHandle) in inputTensorHandles.enumerated() {
+      if _RuntimeConfig.printsDebugLog {
+        dumpCTensorHandleContent(i, inputTensorHandle)
+      }
+      state.addInput(inputTensorHandle)
+    }
+
+    debugLog("Created returning info.")
+    self.returnValues = Array(repeating: nil, count: resultCount)
+
+    debugLog("Starting TF graph execution.")
+
+    // If it's asynchronous, we execute the tensor computation via threads.
+    if !_RuntimeConfig.usesSynchronousExecution {
+      let threadCount = helperFunctionCount + 1
+      for threadIndex in 0..<threadCount {
+        // The function to launch in the parallel thread.
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+        typealias ThreadBody = @convention(c)
+          (UnsafeMutableRawPointer) -> UnsafeMutableRawPointer?
+#else
+        typealias ThreadBody = @convention(c)
+          (UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer?
+#endif
+        let body: ThreadBody = { arg in
+          // Set the cancelability of the detached thread.
+          pthread_setcanceltype(Int32(PTHREAD_CANCEL_DEFERRED), nil)
+          // Execute the tensor computation.
+#if !(os(macOS) || os(iOS) || os(watchOS) || os(tvOS))
+          let arg = arg!
+#endif
+          let param: ThreadParam =
+            Unmanaged.fromOpaque(arg).takeRetainedValue()
+          param.computation.execute(threadIndex: param.threadIndex)
+          checkOk(param.computation.status)
+          return nil
+        }
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+        var newThread: pthread_t!
+#else
+        var newThread = pthread_t()
+#endif
+        let creationStatus = pthread_create(
+          &newThread, nil, body,
+          Unmanaged.passRetained(
+            ThreadParam(computation: self,
+                        threadIndex: threadIndex)).toOpaque()
+        )
+        // TODO(hongm): do error handling.
+        internalConsistencyCheck(creationStatus == 0)
+        pthreads.append(newThread)
+      }
+    }
+    // If it's synchronous, we call execute() on the main thread directly.
+    else {
+      // Log a debug message to differentiate from async computation.
+      debugLog("Running tensor computation synchronously.")
+      execute(threadIndex: 0)
+    }
+    debugLog("Exiting _TensorComputation.init().")
+  }
+
+  deinit {
+    debugLog("De-initializing _TensorComputation.")
+    TF_DeleteStatus(status)
+  }
+}
+
+private extension _TensorComputation {
+  /// In eager mode, runs a device function in a corresponding thread given by
+  /// `threadIndex`. Otherwise, runs all devices functions of the tensor
+  /// program. Aborts the process on error, and emits an error string to STDERR.
+  // NOTE: This is to be called by the initializer. The computation gets
+  // executed on initialization, thus this method will not be exposed to users.
+  private func execute(threadIndex: Int) {
+    debugLog("Executing thread \(threadIndex).")
+    internalConsistencyCheck(threadIndex <= helperFunctionCount)
+    let op = state.ops[threadIndex]
+    if threadIndex == 0 {
+      var returnValueCount = Int32(returnValues.count)
+      TFE_Execute(op, &returnValues, &returnValueCount, status)
+      debugLog("""
+                 returnValues.count=\(returnValues.count), \
+                 returnValueCount=\(returnValueCount).
+                 """)
+      internalConsistencyCheck(returnValueCount == returnValues.count)
+    } else {
+      var returnValueCountForHelper: Int32 = 0
+      TFE_Execute(op, /*returnValues*/nil, &returnValueCountForHelper, status)
+      internalConsistencyCheck(returnValueCountForHelper == 0)
+    }
+    checkOk(status)
+
+    debugLog("Done execution with eager.")
+  }
+}
+
+public extension _TensorComputation {
+  /// Terminates the computation, and clean up the state.
+  func terminate() {
+    for pthread in pthreads {
+      // TODO(hongm): Assess TF's thread cancel support.
+      let cancelStatus = pthread_cancel(pthread)
+      internalConsistencyCheck(cancelStatus == 0)
+    }
+    pthreads.removeAll()
+  }
+
+  /// Waits for completion the computation as given by 'program', and returns
+  /// output handles, whose underlying tensors may live on CPU or GPU.
+  /// Aborts the process on error, and emits an error string to STDERR.
+  func finish() -> [CTensorHandle] {
+    debugLog("Calling _TensorComputation.finish().")
+    if pthreads.isEmpty {
+      internalConsistencyCheck(
+        _RuntimeConfig.usesSynchronousExecution, """
+          finish() is called in async execution mode with pthread == nil -- \
+          Was finish() already called?
+          """)
+    }
+    for pthread in pthreads {
+      debugLog("Waiting for thread to join.")
+      let joinStatus = pthread_join(pthread, nil)
+      internalConsistencyCheck(joinStatus == 0)
+    }
+    pthreads.removeAll()
+    debugLog("Done executing TF graph.")
+
+    // Now that all the elements have been filled in, remove a level of
+    // optional.
+    return returnValues.map { $0! }
+  }
+}
+
+@inlinable
+@_cdecl("_swift_tfc_EagerExecute")
+public func _TFCEagerExecute(_ op: CTFEOp,
+                             _ retvals: UnsafeMutablePointer<OpaquePointer?>,
+                             _ retvalCount: UnsafeMutablePointer<Int32>,
+                             _ status: CTFStatus) {
+  if _RuntimeConfig.printsDebugLog {
+    debugLog("Calling _TFCEagerExecute() over: ")
+    TFE_OpPrintDebugString(op)
+  }
+  if let traceContext = _RuntimeConfig.traceState.context {
+    // convert this eager op into a trace graph node
+    debugLog("Adding eager op \(op) to trace graph.")
+    traceContext.addEagerOpToGraph(op, retvals, retvalCount, status)
+    checkOk(status)
+  } else {
+    debugLog("Executing eager op \(op).")
+    TFE_Execute(op, retvals, retvalCount, status)
+    checkOk(status)
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// - MARK: Compiler runtime entrypoints
+//===----------------------------------------------------------------------===//
+// These are the entrypoints that are well-known to the compiler internals.  The
+// signatures and forms must not be changed without updating the compiler.  Any
+// code put into the body of these functions will end up being inlined into the
+// user code, so they are generally just wrappers around the implementation
+// above.
+
+/// Loads the TF computation from a binary TF FunctionDef proto given by 'bytes'
+/// and 'size', start the computation, and return a _TensorComputation object as
+/// a unique identifier for that computation.
+///
+/// - Parameters:
+///   - programByteAddress: The address of the raw program.
+///   - programByteCount: The number of bytes in the program.
+///   - entryFunctionBaseNameAddress: The base name of the functions to run.
+///   - tensorArgumentAddress: The address to the buffer containing tensor
+///     arguments as CTensorHandle.
+///   - tensorArgumentCount: The number of tensor arguments to pass in.
+///   - helperFunctionCount: The number of helper functions to run.
+///   - resultCount: The number of output tensors.
+@inlinable
+@_silgen_name("_swift_tfc_StartTensorComputation")
+public func _TFCStartTensorComputation(
+  _ programByteAddress: UnsafeRawPointer,
+  _ programByteCount: Int,
+  _ entryFunctionBaseNameAddress: UnsafePointer<Int8>,
+  _ tensorArgumentAddress: UnsafePointer<CTensorHandle>,
+  _ tensorArgumentCount: Int,
+  _ helperFunctionCount: Int,
+  _ resultCount: Int
+) -> _TensorComputation {
+
+  debugLog("""
+    _TFCStartTensorComputation() is called with \(programByteCount) \
+    program bytes, \(tensorArgumentCount) input tensors \
+    \(String(cString:entryFunctionBaseNameAddress)) as the func base name, \
+    \(helperFunctionCount) helper functions, and \(resultCount) output tensors.
+    """)
+
+  internalConsistencyCheck(programByteCount > 0, "Cannot run an empty graph!")
+
+  return _TensorComputation(programByteAddress: programByteAddress,
+                            programByteCount: programByteCount,
+                            entryFunctionBaseNameAddress: entryFunctionBaseNameAddress,
+                            tensorArgumentAddress: tensorArgumentAddress,
+                            tensorArgumentCount: tensorArgumentCount,
+                            helperFunctionCount: helperFunctionCount,
+                            resultCount: resultCount)
+}
+
+/// Waits for completion of the computation as given by `computation`, and
+/// returns results.
+/// Aborts the process on error, and emits an error string to STDERR.
+///
+/// - Parameters:
+///   - computation: The tensor computation to finish.
+///   - tensorResultAddress: The address to an uninitialized buffer to accept
+///     results of the computation, where the output tensors may live on CPU or
+///     GPU.
+///   - tensorResultCount: The number of results to accept from the computation.
+/// - Note: The result address as passed in is pointing to uninitialized memory,
+///   this must initialize the memory, transferring ownership of the tensor
+///   handles to the caller.
+@inlinable
+@_silgen_name("_swift_tfc_FinishTensorComputation")
+public func _TFCFinishTensorComputation(
+  _ computation: _TensorComputation,
+  _ tensorResultAddress: UnsafeMutablePointer<CTensorHandle>,
+  _ tensorResultCount: Int
+) {
+  debugLog("Expecting \(tensorResultCount) output tensors.")
+  let results = computation.finish()
+  internalConsistencyCheck(results.count == tensorResultCount,
+    "internal compiler error: result count mismatch!")
+  tensorResultAddress.initialize(from: results, count: tensorResultCount)
+}
+
+/// Terminates the computation as given by 'program', and clean up the state.
+///
+/// - Parameters:
+///   - program: The tensor program to terminate.
+/// - Note: If the execution was synchronous, then this function does nothing.
+@inlinable
+@_silgen_name("_swift_tfc_TerminateTensorComputation")
+public func _TFCTerminateTensorComputation(_ computation: _TensorComputation) {
+  computation.terminate()
+}
+
+/// Registers all functions in a graph into the eager context if in eager mode.
+///
+/// - Parameters:
+///   - programByteAddress: The address of the raw program.
+///   - programByteCount: The number of bytes in the program.
+@inlinable
+@_silgen_name("_swift_tfc_RegisterTensorFunctions")
+public func _TFCRegisterTensorFunctions(
+  _ programByteAddress: UnsafeRawPointer,
+  _ programByteCount: Int
+) {
+  _ExecutionContext.global.loadFunctionsFromGraph(byteAddress: programByteAddress,
+                                                  byteCount: programByteCount)
+}
+
+/// Creates a scalar CTensorHandle value for the given data type.
+///
+/// - Parameters:
+///   - value: The scalar value.
+///   - dtype: The TF data type of the tensor handle to create.
+/// - Returns: A new CTensorHandle representing the scalar.
+/// - Precondition: T must conform to _TensorFlowDataTypeCompatible and 'dtype'
+///   must be equal to T's corresponding data type.
+/// - TODO(rxwei): Constrain T to _TensorFlowDataTypeCompatible and remove the
+///   precondition. This requires the compiler to emit a call to the generic
+///   function.
+@inlinable
+@_silgen_name("_swift_tfc_CreateCTensorHandle")
+public func _TFCCreateCTensorHandle<T>(_ value: T,
+                                       _ dtype: TF_DataType) -> CTensorHandle {
+  // Create a new CTensor and initialize it to the scalar value.
+  let tensor = TF_AllocateTensor(dtype, nil, 0, MemoryLayout<T>.stride)
+  TF_TensorData(tensor).assumingMemoryBound(to: T.self).initialize(to: value)
+  // Create a new CTensorHandle from the CTensor.
+  let status = TF_NewStatus()
+  let cTensorHandle = TFE_NewTensorHandle(tensor, status)
+  checkOk(status)
+  TF_DeleteStatus(status)
+  TF_DeleteTensor(tensor)
+  return cTensorHandle!
+}
+
+//===----------------------------------------------------------------------===//
+// - MARK: Dynamic compilation (per-op dispatch) entrypoints
+//===----------------------------------------------------------------------===//
+
+@usableFromInline
+@_cdecl("_swift_tfc_GetGlobalEagerContext")
+func _TFCGetGlobalEagerContext() -> CTFEContext {
+  debugLog("Calling _GetGlobalEagerContext()")
+  return _ExecutionContext.global.eagerContext
+}
+
+// Some of the functions are marked with @silgen_name instead of @_cdecl,
+// because their input/output data types are not C-compatible
+// (e.g. AnyTensorHandle).
+
+/// Adds `handle` as an input to `op`.
+@usableFromInline
+@_silgen_name("_swift_tfc_OpAddInputFromTensorHandle")
+func _TFCOpAddInputFromTensorHandle(_ op: CTFEOp,
+                                    _ handle: _AnyTensorHandle,
+                                    _ status: CTFStatus) {
+  TFE_OpAddInput(op, handle._cTensorHandle, status)
+}
+
+/// Adds `t` as an input or inputs to `op`. Returns the number of inputs added.
+@usableFromInline
+@_silgen_name("_swift_tfc_OpAddInputFromTensorGroup")
+func _TFCOpAddInputFromTensorGroup<T : TensorArrayProtocol>(
+    _ op: CTFEOp, _ t: T, _ status: CTFStatus
+) -> Int32 {
+  let count = t._tensorHandleCount
+  let buffer =
+      UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: Int(count))
+  defer { buffer.deallocate() }
+  t._unpackTensorHandles(into: buffer.baseAddress)
+  for handle in buffer {
+    TFE_OpAddInput(op, handle, status)
+    guard TF_GetCode(status) == TF_OK else {
+      return 0
+    }
+  }
+  return count
+}
+
+/// Special protocol for calling tensorflow operations that take heterogeneous
+/// arrays as input.
+public protocol AnyTensor {
+  var _rawTensorHandle: CTensorHandle { get }
+  var _tensorFlowDataType: TensorDataType { get }
+}
+
+@usableFromInline
+func _TFCOpAddInputFromAnyTensors(
+  _ op: CTFEOp, _ tensors: [AnyTensor], _ status: CTFStatus
+) {
+  for tensor in tensors {
+    let handle = tensor._rawTensorHandle
+    TFE_OpAddInput(op, handle, status)
+    checkOk(status)
+  }
+}
+
+/// Initializes a TensorGroup value, taking ownership of all the tensor
+/// handles in `tensorHandles`.
+@usableFromInline
+@_silgen_name("_swift_tfc_InitTensorGroup")
+func _TFCInitTensorGroup<T : TensorGroup>(
+    _ tensorHandles: UnsafeMutablePointer<CTensorHandle>
+) -> T {
+  return T(_owning: tensorHandles)
+}
+
+/// Allocates a buffer of CTensorHandles on the heap.
+@usableFromInline
+@_silgen_name("_swift_tfc_AllocateCHandleBuffer")
+func _TFCAllocateCHandleBuffer(_ capacity: Int32)
+    -> UnsafeMutablePointer<CTensorHandle> {
+  return UnsafeMutablePointer.allocate(capacity: Int(capacity))
+}
+
+/// Deallocates a buffer of CTensorHandles.
+@usableFromInline
+@_silgen_name("_swift_tfc_DeallocateCHandleBuffer")
+func _TFCDeallocateCHandleBuffer(
+    _ buffer: UnsafeMutablePointer<CTensorHandle>
+) {
+  buffer.deallocate()
+}
+
+/// Returns the number of CTensorHandles in a TensorGroup of type T.
+@_silgen_name("_swift_tfc_GetTensorGroupCHandleCount")
+public func _TFCGetTensorGroupCHandleCount<T : TensorGroup>(
+    _ type: T.Type
+) -> Int32 {
+  return T._tensorHandleCount
+}
+
+@inlinable
+@_silgen_name("_swift_tfc_CreateTensorHandleFromC")
+public func _TFCCreateTensorHandleFromC(
+  _ cHandle: CTensorHandle
+) -> _AnyTensorHandle {
+  let dtype = TFE_TensorHandleDataType(cHandle)
+  switch dtype {
+  case TF_BFLOAT16: return TensorHandle<BFloat16>(_owning: cHandle)
+  case TF_UINT8: return TensorHandle<UInt8>(_owning: cHandle)
+  case TF_INT8: return TensorHandle<Int8>(_owning: cHandle)
+  case TF_UINT16: return TensorHandle<UInt16>(_owning: cHandle)
+  case TF_INT16: return TensorHandle<Int16>(_owning: cHandle)
+  case TF_UINT32: return TensorHandle<UInt32>(_owning: cHandle)
+  case TF_INT32: return TensorHandle<Int32>(_owning: cHandle)
+  case TF_UINT64: return TensorHandle<UInt64>(_owning: cHandle)
+  case TF_INT64: return TensorHandle<Int64>(_owning: cHandle)
+  case TF_FLOAT: return TensorHandle<Float>(_owning: cHandle)
+  case TF_DOUBLE: return TensorHandle<Double>(_owning: cHandle)
+  case TF_BOOL: return TensorHandle<Bool>(_owning: cHandle)
+  case TF_STRING: return TensorHandle<String>(_owning: cHandle)
+  case TF_RESOURCE: return ResourceHandle(owning: cHandle)
+  case TF_VARIANT: return VariantHandle(owning: cHandle)
+  default: fatalError("Unsupported dtype \(dtype)")
+  }
+}
+
+// _TFCOpSetAttr*Array functions are wrappers around TFE_OpSetAttr*List
+// functions. The wrappers handle converting the Swift Stdlib Array<T> values
+// into buffers that TFE_OpSetAttr*List functions can read.
+
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrBoolArray")
+func _TFCOpSetAttrBoolArray(_ op: CTFEOp,
+                            _ attrName: UnsafePointer<Int8>,
+                            _ value: Array<Bool>) {
+  value.map({ $0 ? UInt8(1) : UInt8(0) }).withUnsafeBufferPointer { buffer in
+    TFE_OpSetAttrBoolList(op, attrName, buffer.baseAddress, Int32(buffer.count))
+  }
+}
+
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrInt32Array")
+func _TFCOpSetAttrInt32Array(_ op: CTFEOp,
+                             _ attrName: UnsafePointer<Int8>,
+                             _ value: Array<Int32>) {
+  value.map(Int64.init).withUnsafeBufferPointer { buffer in
+    TFE_OpSetAttrIntList(op, attrName, buffer.baseAddress, Int32(buffer.count))
+  }
+}
+
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrInt64Array")
+func _TFCOpSetAttrInt64Array(_ op: CTFEOp,
+                             _ attrName: UnsafePointer<Int8>,
+                             _ value: Array<Int64>) {
+  value.withUnsafeBufferPointer { buffer in
+    TFE_OpSetAttrIntList(op, attrName, buffer.baseAddress, Int32(buffer.count))
+  }
+}
+
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrDoubleArray")
+func _TFCOpSetAttrDoubleArray(_ op: CTFEOp,
+                              _ attrName: UnsafePointer<Int8>,
+                              _ value: Array<Double>) {
+  value.map(Float.init).withUnsafeBufferPointer { buffer in
+    TFE_OpSetAttrFloatList(op, attrName, buffer.baseAddress, Int32(buffer.count))
+  }
+}
+
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrFloatArray")
+func _TFCOpSetAttrFloatArray(_ op: CTFEOp,
+                             _ attrName: UnsafePointer<Int8>,
+                             _ value: Array<Float>) {
+  value.withUnsafeBufferPointer { buffer in
+    TFE_OpSetAttrFloatList(op, attrName, buffer.baseAddress, Int32(buffer.count))
+  }
+}
+
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrTypeArray")
+func _TFCOpSetAttrTypeArray(_ op: CTFEOp,
+                            _ attrName: UnsafePointer<Int8>,
+                            _ value: Array<TensorDataType>) {
+  value.withUnsafeBufferPointer { buffer in
+    buffer.withMemoryRebound(to: TF_DataType.self) { reboundBuffer in
+      TFE_OpSetAttrTypeList(op, attrName, reboundBuffer.baseAddress,
+                            Int32(reboundBuffer.count))
+    }
+  }
+}
+
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrTensorShape")
+func _TFCOpSetAttrTensorShape(_ op: CTFEOp,
+                              _ attrName: UnsafePointer<Int8>,
+                              _ shape: TensorShape,
+                              _ status: CTFStatus) {
+  let dimensions: [Int64] = shape.dimensions.map(Int64.init)
+  dimensions.withUnsafeBufferPointer { buffer in
+    TFE_OpSetAttrShape(op, attrName, buffer.baseAddress, Int32(buffer.count),
+                       status)
+  }
+}
+
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrOptionalTensorShape")
+func _TFCOpSetAttrOptionalTensorShape(_ op: CTFEOp,
+                                      _ attrName: UnsafePointer<Int8>,
+                                      _ optionalShape: TensorShape?,
+                                      _ status: CTFStatus) {
+  guard let shape = optionalShape else {
+    TFE_OpSetAttrShape(op, attrName, nil, -1, status)
+    return
+  }
+  _TFCOpSetAttrTensorShape(op, attrName, shape, status)
+}
+
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrTensorShapeArray")
+func _TFCOpSetAttrTensorShapeArray(_ op: CTFEOp,
+                                   _ attrName: UnsafePointer<Int8>,
+                                   _ value: Array<TensorShape>,
+                                   _ status: CTFStatus) {
+  let flattenedDims = value.flatMap { $0.dimensions.map(Int64.init) }
+  let ranks = value.map { Int32($0.rank) }
+  setAttrShapeList(op: op, attrName: attrName, flattenedDims: flattenedDims,
+                   ranks: ranks, status: status)
+}
+
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrOptionalTensorShapeArray")
+func _TFCOpSetAttrOptionalTensorShapeArray(_ op: CTFEOp,
+                                           _ attrName: UnsafePointer<Int8>,
+                                           _ value: Array<TensorShape?>,
+                                           _ status: CTFStatus) {
+  let flattenedDims = value.flatMap { (tensorShapeOpt) -> [Int64] in
+    if let tensorShape = tensorShapeOpt {
+      return tensorShape.dimensions.map(Int64.init)
+    }
+    return []
+  }
+  let ranks = value.map { shape in (shape?.rank).map(Int32.init) ?? -1 }
+  setAttrShapeList(op: op, attrName: attrName, flattenedDims: flattenedDims,
+                   ranks: ranks, status: status)
+}
+
+/// Given dimensions and ranks in the form described below, makes the
+/// appropriate call to `TFE_OpSetAttrShapeList(op, attrName, ..., status)`.
+///
+/// - Parameters
+///   - flattenedDims: all the shapes' dimensions concatenated together in
+///     order
+///   - ranks: all the shapes' ranks (-1 denotes unknown rank)
+fileprivate func setAttrShapeList(
+  op: CTFEOp, attrName: UnsafePointer<Int8>, flattenedDims: Array<Int64>,
+  ranks: Array<Int32>, status: CTFStatus
+) {
+  flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
+    var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
+    var dims: [UnsafePointer<Int64>?] = []
+    for rank in ranks {
+      dims.append(dimsPtr)
+      if rank >= 0 {
+        dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
+      }
+    }
+    dims.withUnsafeMutableBufferPointer { dimsBuffer in
+      ranks.withUnsafeBufferPointer { ranksBuffer in
+        TFE_OpSetAttrShapeList(op, attrName, dimsBuffer.baseAddress,
+                               ranksBuffer.baseAddress,
+                               Int32(ranksBuffer.count), status)
+      }
+    }
+  }
+}
+
+/// Wrapper around TFE_OpSetAttrString that handles converting the Swift Stdlib
+/// String into a buffer that TFE_OpSetAttrString can read.
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrString")
+func _TFCOpSetAttrString(_ op: CTFEOp,
+                         _ attrName: UnsafePointer<Int8>,
+                         _ value: String) {
+  value.utf8CString.withUnsafeBufferPointer { buffer in
+    // utf8CString is null-terminated; TFE_OpSetAttrString wants
+    // non-null-terminated.
+    TFE_OpSetAttrString(op, attrName, buffer.baseAddress, buffer.count - 1)
+  }
+}
+
+/// Wrapper around TFE_OpSetAttrFunctionName that handles converting the Swift
+/// Stdlib String into a buffer that TFE_OpSetAttrFunctionName can read.
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrFunctionName")
+func _TFCOpSetAttrFunctionName(_ op: CTFEOp,
+                               _ attrName: UnsafePointer<Int8>,
+                               _ value: String) {
+  value.utf8CString.withUnsafeBufferPointer { buffer in
+    // utf8CString is null-terminated; TFE_OpSetAttrFunctionName wants
+    // non-null-terminated.
+    TFE_OpSetAttrFunctionName(op, attrName, buffer.baseAddress, buffer.count - 1)
+  }
+}
+
+/// Wrapper around TFE_OpSetAttrStringList that handles converting the Swift
+/// Strings into buffers that TFE_OpSetAttrStringList can read.
+@usableFromInline
+@_silgen_name("_swift_tfc_OpSetAttrStringArray")
+func _TFCOpSetAttrStringArray(_ op: CTFEOp,
+                             _ attrName: UnsafePointer<Int8>,
+                             _ strings: [String]) {
+  // Collect all the strings' utf8 bytes into a single array so that we can
+  // address all the strings with a single
+  // `flattenedStringBytes.withUnsafeBufferPointer`.
+  var flattenedStringBytes: [CChar] = []
+  var lengths: [Int] = []
+  for string in strings {
+    // Don't include the null-terminator because TFE_OpSetAttrStringList uses
+    // lengths instead of null-terminators.
+    let stringBytes = string.utf8CString.dropLast()
+    flattenedStringBytes.append(contentsOf: stringBytes)
+    lengths.append(stringBytes.count)
+  }
+
+  // Calculate the addresses of all the strings within our single buffer, and
+  // then call TFE_OpSetAttrStringList.
+  flattenedStringBytes.withUnsafeBufferPointer { flattenedStringBytesBuffer in
+    var stringAddrs: [UnsafeRawPointer?] = []
+    var currentStringAddr =
+        flattenedStringBytesBuffer.baseAddress.map(UnsafeRawPointer.init)
+    for length in lengths {
+      stringAddrs.append(currentStringAddr)
+      currentStringAddr = currentStringAddr?.advanced(by: length)
+    }
+
+    stringAddrs.withUnsafeBufferPointer { stringAddrsBuffer in
+      lengths.withUnsafeBufferPointer { lengthsBuffer in
+        TFE_OpSetAttrStringList(op, attrName, stringAddrsBuffer.baseAddress,
+                                lengthsBuffer.baseAddress, Int32(strings.count))
+      }
+    }
+  }
+}
+
+@usableFromInline
+class _ThreadLocalState {
+  var deviceScopes: [(kind: DeviceKind, index: UInt)?] = []
+
+  private static let key: pthread_key_t = {
+    var key = pthread_key_t()
+    pthread_key_create(&key) {
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+      let _: AnyObject = Unmanaged.fromOpaque($0).takeRetainedValue()
+#else
+      let _: AnyObject = Unmanaged.fromOpaque($0!).takeRetainedValue()
+#endif
+    }
+    return key
+  }()
+
+  var _currentDevice: (DeviceKind, UInt)? {
+    return deviceScopes.last ?? nil
+  }
+
+  @usableFromInline
+  func pushDevice(_ device: (DeviceKind, UInt)?) {
+    deviceScopes.append(device)
+  }
+
+  @usableFromInline
+  func popDevice() {
+    internalConsistencyCheck(deviceScopes.popLast() != nil)
+  }
+
+  @usableFromInline
+  static var value: _ThreadLocalState {
+    if let state = pthread_getspecific(key) {
+      return Unmanaged.fromOpaque(state).takeUnretainedValue()
+    }
+    let state = _ThreadLocalState()
+    pthread_setspecific(key, Unmanaged.passRetained(state).toOpaque())
+    return state
+  }
+}
+
+@usableFromInline
+@_cdecl("_swift_tfc_OpSetDeviceFromScope")
+func _TFCOpSetDeviceFromScope(_ op: CTFEOp, _ status: CTFStatus) {
+  if let deviceName = _ExecutionContext.global.currentDeviceName {
+    TFE_OpSetDevice(op, deviceName, status)
+  }
+}
+
+@usableFromInline
+@_cdecl("_swift_tfc_CheckOk")
+func _TFCCheckOk(_ s: CTFStatus) {
+  checkOk(s)
+}
diff --git a/Sources/DeepLearning/Core/ShapedArray.swift b/Sources/TensorFlow/Core/ShapedArray.swift
similarity index 99%
rename from Sources/DeepLearning/Core/ShapedArray.swift
rename to Sources/TensorFlow/Core/ShapedArray.swift
index dff4dd3d1..f62f4a5eb 100644
--- a/Sources/DeepLearning/Core/ShapedArray.swift
+++ b/Sources/TensorFlow/Core/ShapedArray.swift
@@ -14,7 +14,6 @@
 
 import Swift
 import CTensorFlow
-import TensorFlowCore
 
 //===------------------------------------------------------------------------------------------===//
 // TensorBuffer
diff --git a/Sources/DeepLearning/Core/StringTensor.swift b/Sources/TensorFlow/Core/StringTensor.swift
similarity index 99%
rename from Sources/DeepLearning/Core/StringTensor.swift
rename to Sources/TensorFlow/Core/StringTensor.swift
index d67b0574c..976850f99 100644
--- a/Sources/DeepLearning/Core/StringTensor.swift
+++ b/Sources/TensorFlow/Core/StringTensor.swift
@@ -13,7 +13,6 @@
 // limitations under the License.
 
 import CTensorFlow
-import TensorFlowCore
 
 //===------------------------------------------------------------------------------------------===//
 // StringTensor
diff --git a/Sources/DeepLearning/Core/Tensor.swift b/Sources/TensorFlow/Core/Tensor.swift
similarity index 87%
rename from Sources/DeepLearning/Core/Tensor.swift
rename to Sources/TensorFlow/Core/Tensor.swift
index 90669442c..e44e64f12 100644
--- a/Sources/DeepLearning/Core/Tensor.swift
+++ b/Sources/TensorFlow/Core/Tensor.swift
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 infix operator .==: ComparisonPrecedence
 infix operator .!=: ComparisonPrecedence
 
@@ -158,11 +156,8 @@ public extension Tensor {
         @inline(__always)
         get {
             debugLog("Returning a host copy of array.")
-            internalConsistencyCheck(toHost().handle.isConcrete)
-
-            // This is considered to be a well known way to produce a copy to the host, so an 
-            // "implicit copy to host" warning should not be produced.
-            return toHost().handle.makeHostCopy()
+            internalConsistencyCheck(handle.isConcrete)
+	        return handle.makeHostCopy()
         }
     }
 
@@ -172,55 +167,6 @@ public extension Tensor {
     }
 }
 
-//===------------------------------------------------------------------------------------------===//
-// Memory Transfer Markers
-//===------------------------------------------------------------------------------------------===//
-
-public extension Tensor {
-    /// Mark memory transfer to accelerator.
-    /// - Parameters:
-    ///   - shape: When sending the tensor to a TF XLA device (including TPU), must specify the 
-    ///     tensor shape as required by XLA compilation.
-    @inlinable @inline(__always)
-    func toAccelerator(shape: TensorShape) -> Tensor {
-        let tensor = toAccelerator()
-        // If the tensor is to be sent from host to TPU, the shape is specified on TF CPU first, 
-        // before TF CPU sends the tensor to TPU.
-        let ret: TensorHandle<Scalar> = #tfop(
-            "Identity",
-            tensor,
-            T$dtype: Scalar.tensorFlowDataType,
-            __shapes: [shape],
-            __device: "/job:localhost/replica:0/task:0/device:CPU:0")
-        return Tensor(handle: ret)
-    }
-
-    /// Mark memory transfer to accelerator.
-    @inlinable @inline(__always)
-    func toAccelerator() -> Tensor {
-        return Tensor(handle: _TFToAccelerator(handle))
-    }
-
-    /// Mark memory transfer to host.
-    /// - Parameters:
-    ///   - shape: When sending the tensor to a TF XLA device (including TPU), must specify the 
-    ///     tensor shape as required by XLA compilation.
-    @inlinable @inline(__always)
-    func toHost(shape: TensorShape) -> Tensor {
-        // If the `self` tensor resides on TPU, the shape is specified on that device first, before 
-        // outfeeding the tensor to CPU, a required step for sending the tensor to the host.
-        let tensor: TensorHandle<Scalar> = #tfop(
-            "Identity", self, T$dtype: Scalar.tensorFlowDataType, __shapes: [shape])
-        return Tensor(handle: tensor).toHost()
-    }
-
-    /// Mark memory transfer to host.
-    @inlinable @inline(__always)
-    func toHost() -> Tensor {
-        return Tensor(handle: _TFToHost(handle))
-    }
-}
-
 //===------------------------------------------------------------------------------------------===//
 // Initialization
 //===------------------------------------------------------------------------------------------===//
@@ -420,9 +366,7 @@ extension _TensorElementLiteral: ExpressibleByArrayLiteral {
     public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
     @inlinable @inline(__always)
     public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...) {
-        // FIXME: We cannot use Raw.pack here because _TensorElementLiteral does not
-        // conform to tensor group and if we do, several partitioning tests fail.
-        self.init(handle: #tfop("Pack", elements, T$dtype: Scalar.tensorFlowDataType))
+        tensor = Raw.pack(elements.map { $0.tensor })
     }
 }
 
@@ -432,12 +376,10 @@ extension Tensor: ExpressibleByArrayLiteral {
 
     /// Creates a tensor initialized with the given elements.
     /// - Note: This is for conversion from tensor element literals. This is a
-    /// separate method because `ShapedArray` initializers need to call it.
+    ///   separate method because `ShapedArray` initializers need to call it.
     @inlinable @inline(__always)
     internal init(_tensorElementLiterals elements: [_TensorElementLiteral<Scalar>]) {
-        // FIXME: We cannot use Raw.pack here because _TensorElementLiteral does not
-        // conform to tensor group and if we do, several partitioning tests fail.
-        self.init(handle: #tfop("Pack", elements, T$dtype: Scalar.tensorFlowDataType))
+        self = Raw.pack(elements.map { $0.tensor })
     }
 
     /// Creates a tensor initialized with the given elements.
@@ -553,9 +495,9 @@ extension Tensor: Codable where Scalar: Codable {
     }
 }
 
-//===-------------------------------------------------------------------------------------------===//
+//===------------------------------------------------------------------------------------------===//
 // Additive Group
-//===-------------------------------------------------------------------------------------------===//
+//===------------------------------------------------------------------------------------------===//
 
 extension Tensor: AdditiveArithmetic where Scalar: Numeric {
     /// A scalar zero tensor.
@@ -627,9 +569,9 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
     }
 }
 
-//===-------------------------------------------------------------------------------------------===//
+//===------------------------------------------------------------------------------------------===//
 // Differentiable
-//===-------------------------------------------------------------------------------------------===//
+//===------------------------------------------------------------------------------------------===//
 
 extension Tensor: Differentiable where Scalar: TensorFlowFloatingPoint {
     public typealias TangentVector = Tensor
diff --git a/Sources/TensorFlow/Core/TensorGroup.swift b/Sources/TensorFlow/Core/TensorGroup.swift
new file mode 100644
index 000000000..bb6958136
--- /dev/null
+++ b/Sources/TensorFlow/Core/TensorGroup.swift
@@ -0,0 +1,231 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+import CTensorFlow
+
+/// A protocol representing types that can be mapped to `Array<CTensorHandle>`.
+///
+/// This protocol is defined separately from `TensorGroup` in order for the number of tensors to be 
+/// determined at runtime. For example, `[Tensor<Float>]` may have an unknown number of elements at 
+/// compile time.
+///
+/// This protocol can be derived automatically for structs whose stored properties all conform to 
+/// the `TensorGroup` protocol. It cannot be derived automatically for structs whose properties all 
+/// conform to `TensorArrayProtocol` due to the constructor requirement (i.e., in such cases it
+/// would be impossible to know how to break down `count` among the stored properties).
+public protocol TensorArrayProtocol {
+    /// Writes the tensor handles to `address`, which must be allocated with enough capacity to hold
+    /// `_tensorHandleCount` handles. The tensor handles written to `address` are borrowed: this
+    /// container still owns them.
+    func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?)
+
+    var _tensorHandleCount: Int32 { get }
+    var _typeList: [TensorDataType] { get }
+
+    init(_owning tensorHandles: UnsafePointer<CTensorHandle>?, count: Int)
+}
+
+/// A protocol representing types that can be mapped to and from `Array<CTensorHandle>`.
+///
+/// When a `TensorGroup` is used as an argument to a tensor operation, it is passed as an argument 
+/// list whose elements are the tensor fields of the type.
+///
+/// When a `TensorGroup` is returned as a result of a tensor operation, it is initialized with its
+/// tensor fields set to the tensor operation's tensor results.
+public protocol TensorGroup: TensorArrayProtocol {
+    /// The types of the tensor stored properties in this type.
+    static var _typeList: [TensorDataType] { get }
+
+    /// An array of `nil`s with the same number of elements as `_outputTypeList`. The `nil`
+    /// represents unknown shape.
+    // TODO: This is a protocol requirement so that conformances can provide custom const-evaluable 
+    // implementations. When the const-evaluator is powerful enough to evaluate the default
+    // implementation, remove this requirement.
+    static var _unknownShapeList: [TensorShape?] { get }
+
+    /// Initializes a value of this type, taking ownership of the `_tensorHandleCount` tensors
+    /// starting at address `tensorHandles`.
+    init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)
+}
+
+public extension TensorGroup {
+    /// The number of tensor fields in this type.
+    static var _tensorHandleCount: Int32 { return Int32(Self._typeList.count) }
+
+    /// An array of `nil`s with the same number of elements as `_outputTypeList`. The `nil`
+    /// represents unknown shape.
+    static var _unknownShapeList: [TensorShape?] {
+        return Array(repeating: nil, count: _typeList.count)
+    }
+    
+    // The following instance properties are from `TensorArrayProtocol`.
+    var _tensorHandleCount: Int32 { return Int32(Self._typeList.count) }
+    var _typeList: [TensorDataType] { return Self._typeList }
+
+    init(_owning tensorHandles: UnsafePointer<CTensorHandle>?, count: Int) {
+        precondition(count == Self._typeList.count)
+        self.init(_owning: tensorHandles)
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// TensorGroup Conformances
+//===------------------------------------------------------------------------------------------===//
+
+extension TensorHandle: TensorGroup {
+    @inlinable
+    public static var _unknownShapeList: [TensorShape?] {
+        return [nil]
+    }
+
+    @inlinable
+    public static var _typeList: [TensorDataType] {
+        return [Scalar.tensorFlowDataType]
+    }
+
+    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
+        address!.initialize(to: _cTensorHandle)
+    }
+
+    public convenience init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
+        self.init(_owning: tensorHandles!.pointee)
+    }
+}
+
+extension ResourceHandle: TensorGroup {
+    @inlinable
+    public static var _unknownShapeList: [TensorShape?] {
+        return [nil]
+    }
+
+    @inlinable
+    public static var _typeList: [TensorDataType] {
+        return [TensorDataType(TF_RESOURCE)]
+    }
+
+    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
+        address!.initialize(to: _cTensorHandle)
+    }
+
+    public convenience init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
+        self.init(owning: tensorHandles!.pointee)
+    }
+}
+
+extension VariantHandle: TensorGroup {
+    @inlinable
+    public static var _unknownShapeList: [TensorShape?] {
+        return [nil]
+    }
+
+    @inlinable
+    public static var _typeList: [TensorDataType] {
+        return [TensorDataType(TF_VARIANT)]
+    }
+
+    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
+        address!.initialize(to: _cTensorHandle)
+    }
+
+    public convenience init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
+        self.init(owning: tensorHandles!.pointee)
+    }
+}
+
+extension Tensor: TensorGroup {
+    @inlinable
+    public static var _unknownShapeList: [TensorShape?] {
+        return [nil]
+    }
+
+    @inlinable
+    public static var _typeList: [TensorDataType] {
+        return [Scalar.tensorFlowDataType]
+    }
+
+    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
+        address!.initialize(to: handle._cTensorHandle)
+    }
+
+    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
+        self.init(handle: TensorHandle(_owning: tensorHandles!.pointee))
+    }
+}
+
+extension _TensorElementLiteral: TensorGroup {
+    @inlinable
+    public static var _unknownShapeList: [TensorShape?] {
+        return [nil]
+    }
+
+    @inlinable
+    public static var _typeList: [TensorDataType] {
+        return [Scalar.tensorFlowDataType]
+    }
+
+    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
+        address!.initialize(to: handle._cTensorHandle)
+    }
+
+    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
+        self.init(handle: TensorHandle(_owning: tensorHandles!.pointee))
+    }
+}
+
+extension StringTensor: TensorGroup {
+    @inlinable
+    public static var _unknownShapeList: [TensorShape?] {
+        return [nil]
+    }
+
+    @inlinable
+    public static var _typeList: [TensorDataType] {
+        return [String.tensorFlowDataType]
+    }
+
+    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
+        address!.initialize(to: handle._cTensorHandle)
+    }
+
+    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
+        self.init(handle: TensorHandle(_owning: tensorHandles!.pointee))
+    }
+}
+
+extension Array: TensorArrayProtocol where Element: TensorGroup {
+    public func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?) {
+        var ptr = address
+        for elem in self {
+            elem._unpackTensorHandles(into: ptr)
+            ptr = ptr!.advanced(by: Int(elem._tensorHandleCount))
+        }
+    }
+
+    public var _tensorHandleCount: Int32 {
+        return Element._tensorHandleCount * Int32(count)
+    }
+
+    public var _typeList: [TensorDataType] {
+        return Array<TensorDataType>([[TensorDataType]](
+            repeating: Element._typeList,
+            count: Int(count)).joined())
+    }
+
+    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?, count: Int) {
+        let size = count / Int(Element._tensorHandleCount)
+        self = Array((0..<size).map { Element.init(
+            _owning: tensorHandles?.advanced(by: $0 * Int(Element._tensorHandleCount)))
+        })
+    }
+}
diff --git a/Sources/TensorFlow/Core/TensorHandle.swift b/Sources/TensorFlow/Core/TensorHandle.swift
new file mode 100644
index 000000000..6a181f658
--- /dev/null
+++ b/Sources/TensorFlow/Core/TensorHandle.swift
@@ -0,0 +1,269 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+import CTensorFlow
+
+/// `_AnyTensorHandle` is the scalar-agnostic base type for `TensorHandle`, used specifically for
+/// low-level, type-erased passings of Swift-level tensor handles in the compiler.
+@_fixed_layout // required because the compiler accesses _cTensorHandle directly.
+public class _AnyTensorHandle {
+    /// The underlying `TFE_TensorHandle *`.
+    ///
+    /// - Note: The compiler knows that `_AnyTensorHandle` has a single stored property, and assumes 
+    ///   that this is it. Changing the design of `TensorHandle` will require tweaking the compiler.
+    public let _cTensorHandle: CTensorHandle
+
+    /// Private initializer from a `CTensorHandle`. Should only be called from
+    /// `TensorHandle<Scalar>.init`.
+    fileprivate init(base: CTensorHandle) {
+        self._cTensorHandle = base
+    }
+}
+
+
+/// `TensorHandle` is the type used by ops. It includes a `Scalar` type, which compiler internals 
+/// use to determine the datatypes of parameters when they are extracted into a tensor program.
+@_fixed_layout // required because the compiler accesses _cTensorHandle directly.
+public final class TensorHandle<Scalar>: _AnyTensorHandle
+    where Scalar: _TensorFlowDataTypeCompatible {
+    public init(_owning cTensorHandle: CTensorHandle) {
+        super.init(base: cTensorHandle)
+    }
+
+    @inlinable
+    public convenience init(copyingFromCTensor cTensor: CTensor) {
+        let status = TF_NewStatus()
+        let cTensorHandle = TFE_NewTensorHandle(cTensor, status)
+        checkOk(status)
+        self.init(_owning: cTensorHandle!)
+        TF_DeleteStatus(status)
+    }
+
+    deinit {
+        debugLog("De-initializing TensorHandle.")
+        TFE_DeleteTensorHandle(_cTensorHandle)
+        debugLog("Returning from deinit of TensorHandle.")
+    }
+
+    /// Create a `TensorHandle` with a closure that initializes the underlying buffer.
+    ///
+    /// Users initializing `TensorHandle`s with non-`String` scalars should use the
+    /// `init(shape:scalarsInitializer:)` initializer instead of this one. It enforces additional
+    /// constraints on the buffer that hold for all non-`String` scalars.
+    ///
+    /// `bufferInitializer` receives a buffer with exactly `byteCount` bytes of capacity.
+    /// `bufferInitializer` must initialize the entire buffer.
+    @inlinable
+    public convenience init(
+        shape: [Int],
+        byteCount: Int,
+        bufferInitializer: (UnsafeMutableRawPointer) -> Void
+    ) {
+        let cTensor = TF_AllocateTensor(
+            Scalar.tensorFlowDataType._cDataType,
+            shape.map(Int64.init),
+            Int32(shape.count),
+            byteCount)!
+        assert(TF_TensorByteSize(cTensor) == byteCount)
+        bufferInitializer(TF_TensorData(cTensor))
+        self.init(copyingFromCTensor: cTensor)
+        TF_DeleteTensor(cTensor)
+    }
+
+    /// Return true if the underlying tensor is concrete (as opposed to being symbolic).
+    public var isConcrete: Bool {
+        return TFE_TensorHandleIsConcrete(_cTensorHandle) != 0
+    }
+}
+
+extension TensorHandle where Scalar: TensorFlowScalar {
+    /// Create a `TensorHandle` with a closure that initializes the underlying buffer.
+    ///
+    /// `scalarsInitializer` receives a buffer with exactly enough capacity to hold the scalars in a 
+    /// tensor with shape `shape`. `scalarsInitializer` must initialize the entire buffer, with
+    /// contiguous scalars in row-major order.
+    @inlinable
+    public convenience init(
+        shape: [Int],
+        scalarsInitializer: (UnsafeMutablePointer<Scalar>) -> Void
+    ) {
+        let contiguousSize = shape.reduce(1, *)
+        let byteCount = contiguousSize * MemoryLayout<Scalar>.stride
+        self.init(shape: shape, byteCount: byteCount, bufferInitializer: { buffer in
+            let pointer = buffer.bindMemory(to: Scalar.self, capacity: contiguousSize)
+            scalarsInitializer(pointer)
+        })
+    }
+}
+
+internal extension TensorHandle {
+    /// Create a `ShapedArray` with contents of the underlying `TensorHandle`. If the `TensorHandle` 
+    /// is on the accelerator, it will be copied to the host.
+    /// - Returns: A `ShapedArray`.
+    @usableFromInline
+    @inline(never)
+    func makeHostCopy() -> ShapedArray<Scalar> {
+        internalConsistencyCheck(isConcrete)
+        debugLog("Calling makeHostCopy() with c handle \(_cTensorHandle)")
+        return ShapedArray(cTensorHandle: _cTensorHandle)
+    }
+}
+
+extension TensorHandle: TensorSendableReceivable {
+    @inlinable
+    static func receiveFromAccelerator(
+        _ computation: _TensorComputation,
+        _ tensorID: Int
+    ) -> TensorHandle<Scalar> {
+        debugLog("Receiving tensor of id \(tensorID) and type \(Scalar.self).")
+        let status = TF_NewStatus()
+        internalConsistencyCheck(status != nil)
+        let tensorHandle: TensorHandle<Scalar>
+        let context = _ExecutionContext.global
+        let cTensorHandle = TFE_DequeueNamedTensorFromCtx(
+            context.eagerContext, Int32(tensorID),
+            Scalar.tensorFlowDataType._cDataType, status)
+        checkOk(status)
+        tensorHandle = TensorHandle<Scalar>(_owning: cTensorHandle!)
+        if _RuntimeConfig.printsDebugLog {
+            debugLog("The received tensor of id \(tensorID) has content:")
+            dumpTensorContent(tensorHandle._cTensorHandle, Scalar.self)
+        }
+        return tensorHandle
+    }
+
+    @inlinable
+    func sendToAccelerator(_ computation: _TensorComputation, _ tensorID: Int) {
+        if _RuntimeConfig.printsDebugLog {
+            debugLog("Sending tensor of id \(tensorID) and type \(Scalar.self) with:")
+            dumpTensorContent(_cTensorHandle, Scalar.self)
+        }
+        let status = TF_NewStatus()
+        internalConsistencyCheck(status != nil)
+        let context = _ExecutionContext.global
+        TFE_EnqueueNamedTensorFromCtx(context.eagerContext, Int32(tensorID), _cTensorHandle, status)
+        debugLog("Tensor is sent.")
+        checkOk(status)
+        TF_DeleteStatus(status)
+    }
+
+    @inlinable
+    static func scalar(_ scalar: Scalar) -> TensorHandle<Scalar> {
+        debugLog("Creating a tensor from scalar \(scalar).")
+        let cTensorHandle = _TFCCreateCTensorHandle(scalar, Scalar.tensorFlowDataType._cDataType)
+        return TensorHandle<Scalar>(_owning: cTensorHandle)
+    }
+}
+
+/// `ResourceHandle` is the type used by ops to represent TensorFlow "resource" values.
+public final class ResourceHandle: _AnyTensorHandle {
+    @usableFromInline
+    init(owning cTensorHandle: CTensorHandle) {
+        super.init(base: cTensorHandle)
+    }
+
+    deinit {
+        debugLog("De-initializing TensorHandle.")
+        TFE_DeleteTensorHandle(_cTensorHandle)
+        debugLog("Returning from deinit of ResourceHandle.")
+    }
+}
+
+extension ResourceHandle: TensorSendableReceivable {
+    @inlinable
+    static func receiveFromAccelerator(
+        _ computation: _TensorComputation,
+        _ tensorID: Int
+    ) -> ResourceHandle {
+        debugLog("Receiving resource tensor of id \(tensorID).")
+        let status = TF_NewStatus()
+        let context = _ExecutionContext.global
+        let cTensorHandle: CTensorHandle! = TFE_DequeueNamedTensorFromCtx(
+            context.eagerContext, Int32(tensorID), TF_RESOURCE, status)
+        checkOk(status)
+        TF_DeleteStatus(status)
+        debugLog("Done receiving resource tensor of id \(tensorID).")
+        return ResourceHandle(owning: cTensorHandle)
+    }
+
+    @inlinable
+    func sendToAccelerator(_ computation: _TensorComputation, _ tensorID: Int) {
+        debugLog("Sending resource tensor of id \(tensorID).")
+        let status = TF_NewStatus()
+        let context = _ExecutionContext.global
+        TFE_EnqueueNamedTensorFromCtx(
+            context.eagerContext, Int32(tensorID), self._cTensorHandle, status)
+        TF_DeleteStatus(status)
+        debugLog("Done sending resource tensor of id \(tensorID).")
+    }
+
+    // TODO: Remove this dummy `Scalar` typealias, currently required in order to conform to
+    // `TensorSendableReceivable`.
+    @usableFromInline typealias Scalar = Float
+    @inlinable
+    static func scalar(_ scalar: Scalar) -> ResourceHandle {
+        fatalError("Unsupported")
+    }
+}
+
+/// `VariantHandle` is the type used by ops to represent TensorFlow "variant" values.
+public final class VariantHandle: _AnyTensorHandle {
+    @usableFromInline
+    init(owning cTensorHandle: CTensorHandle) {
+        super.init(base: cTensorHandle)
+    }
+
+    deinit {
+        debugLog("De-initializing TensorHandle.")
+        TFE_DeleteTensorHandle(_cTensorHandle)
+        debugLog("Returning from deinit of VariantHandle.")
+    }
+}
+
+extension VariantHandle: TensorSendableReceivable {
+    @inlinable
+    static func receiveFromAccelerator(
+        _ computation: _TensorComputation,
+        _ tensorID: Int
+    ) -> VariantHandle {
+        debugLog("Receiving variant tensor of id \(tensorID).")
+        let status = TF_NewStatus()
+        let context = _ExecutionContext.global
+        let cTensorHandle: CTensorHandle! = TFE_DequeueNamedTensorFromCtx(
+            context.eagerContext, Int32(tensorID), TF_VARIANT, status)
+        checkOk(status)
+        TF_DeleteStatus(status)
+        debugLog("Done receiving variant tensor of id \(tensorID).")
+        return VariantHandle(owning: cTensorHandle)
+    }
+
+    @inlinable
+    func sendToAccelerator(_ computation: _TensorComputation, _ tensorID: Int) {
+        debugLog("Sending variant tensor of id \(tensorID).")
+        let status = TF_NewStatus()
+        let context = _ExecutionContext.global
+        TFE_EnqueueNamedTensorFromCtx(
+            context.eagerContext, Int32(tensorID), self._cTensorHandle, status)
+        TF_DeleteStatus(status)
+        debugLog("Done sending variant tensor of id \(tensorID).")
+    }
+
+    // TODO: Remove this dummy `Scalar` typealias, currently required in order to conform to
+    // `TensorSendableReceivable`.
+    @usableFromInline typealias Scalar = Float
+    @inlinable
+    static func scalar(_ scalar: Scalar) -> VariantHandle {
+        fatalError("Unsupported")
+    }
+}
diff --git a/Sources/TensorFlow/Core/TensorProtocol.swift b/Sources/TensorFlow/Core/TensorProtocol.swift
new file mode 100644
index 000000000..ca93b342a
--- /dev/null
+++ b/Sources/TensorFlow/Core/TensorProtocol.swift
@@ -0,0 +1,51 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+public protocol TensorProtocol {
+    /// Scalar type.
+    associatedtype Scalar: TensorFlowScalar
+
+    /// The underlying `TensorHandle`.
+    /// - Note: Do NOT remove this. This is a compiler requirement.
+    var handle: TensorHandle<Scalar> { get }
+
+    /// Initialize from a `TensorHandle`.
+    /// - Note: Do NOT remove this. This is a compiler requirement.
+    init(handle: TensorHandle<Scalar>)
+}
+
+/// The protocol on tensor sends and receives.
+///
+/// - Note: The compiler knows about this protocol and generates code to use it. So changing the 
+///   protocol design requires changing the compiler accordingly too.
+protocol TensorSendableReceivable {
+    associatedtype Scalar
+
+    /// Receive a tensor based on a tensor computation handle (equivalent to a TF session handle),
+    /// and a tensor ID.
+    static func receiveFromAccelerator(_ computation: _TensorComputation, _ tensorID: Int) -> Self
+
+    /// Send a tensor of `this` instance based on a tensor computation handle (equivalent to a TF
+    /// session handle), and a tensor ID.
+    func sendToAccelerator(_ computation: _TensorComputation, _ tensorID: Int)
+
+    /// Create a scalar tensor. It can be used by the host program to send a scalar value to
+    /// accelerator.
+    ///
+    /// - Note: This is different from protocol method `TensorFlowScalar._makeScalarTensor()`, a 
+    ///   marker function to assist compiler in generating Accelerator code, and has no runtime
+    ///   effects.
+    static func scalar(_ scalar: Scalar) -> Self
+}
+
diff --git a/Sources/TensorFlow/Core/TensorShape.swift b/Sources/TensorFlow/Core/TensorShape.swift
new file mode 100644
index 000000000..42eb5c012
--- /dev/null
+++ b/Sources/TensorFlow/Core/TensorShape.swift
@@ -0,0 +1,167 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+// NOTE: it may be possible to edit `TensorShape` to support "labeled tensors". Dimensions may be
+// either an Int or an enum representing a label.
+
+/// A struct representing the shape of a tensor.
+///
+/// `TensorShape` is a thin wrapper around an array of integers that represent shape dimensions. All
+/// tensor types use `TensorShape` to represent their shape.
+@_fixed_layout
+public struct TensorShape: ExpressibleByArrayLiteral {
+    /// The dimensions of the shape.
+    public var dimensions: [Int]
+
+    /// Initialize with an array of dimensions. The rank of the tensor is the length of the array.
+    /// - Parameter dimensions: The shape dimensions.
+    @inlinable @inline(__always)
+    public init(_ dimensions: [Int]) {
+        self.dimensions = dimensions
+    }
+
+    /// Initialize with a collection of dimensions. The rank of the tensor is the length of the
+    /// collection.
+    /// - Parameter dimensions: The shape dimensions.
+    @inlinable @inline(__always)
+    public init<C: Collection>(_ dimensions: C) where C.Element == Int {
+        self.dimensions = Array(dimensions)
+    }
+
+    /// Initialize with an array literal representing the shape dimensions. The rank of the tensor
+    /// is the number of dimensions.
+    /// - Parameter dimensions: The shape dimensions.
+    @inlinable @inline(__always)
+    public init(arrayLiteral elements: Int...) {
+        self.init(elements)
+    }
+
+    /// Initialize with variadic elements representing the shape dimensions. The rank of the tensor
+    /// is the number of elements.
+    /// - Parameter dimensions: The shape dimensions.
+    @inlinable @inline(__always)
+    public init(_ elements: Int...) {
+        self.init(elements)
+    }
+
+    @inlinable @inline(__always)
+    public init(repeating repeatedValue: Int, count: Int) {
+        self.init(Array(repeating: repeatedValue, count: count))
+    }
+
+    /// The rank of the shape (i.e. the number of dimensions).
+    @inlinable
+    public var rank: Int {
+        @inline(__always)
+        get {
+            return dimensions.count
+        }
+    }
+
+    /// The size of the shape as a contiguously stored array.
+    @inlinable
+    public var contiguousSize: Int {
+        @inline(__always)
+        get {
+            return dimensions.reduce(1, *)
+        }
+    }
+}
+
+public extension TensorShape {
+    /// The rank of the shape (i.e. the number of dimensions).
+    @inlinable
+    var count: Int {
+        @inline(__always)
+        get {
+            return dimensions.count
+        }
+    }
+
+    @inlinable
+    var indices: Range<Int> {
+        @inline(__always)
+        get {
+            return dimensions.indices.lowerBound ..< dimensions.indices.upperBound
+        }
+    }
+
+    @inlinable
+    var startIndex: Int {
+        @inline(__always)
+        get {
+            return dimensions.startIndex
+        }
+    }
+
+    @inlinable
+    var endIndex: Int {
+        @inline(__always)
+        get {
+            return dimensions.endIndex
+        }
+    }
+
+    /// Access the size of the i-th dimension.
+    /// - Parameter index: The index of a dimension.
+    @inlinable
+    subscript(index: Int) -> Int {
+        @inline(__always)
+        _read { yield dimensions[index] }
+        @inline(__always)
+        _modify { yield &dimensions[index] }
+    }
+
+    /// Access the size of the i-th dimension.
+    /// - Parameter index: The index of a dimension.
+    @inlinable
+    subscript(bounds: Range<Int>) -> TensorShape {
+        @inline(__always)
+        get {
+            return TensorShape(dimensions[bounds])
+        }
+        @inline(__always)
+        set {
+            dimensions[bounds] = ArraySlice(newValue.dimensions)
+        }
+    }
+}
+
+extension TensorShape: Equatable {
+    @inlinable @inline(__always)
+    public static func == (lhs: TensorShape, rhs: TensorShape) -> Bool {
+        return lhs.dimensions == rhs.dimensions
+    }
+}
+
+extension TensorShape: Codable {
+    @inlinable
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(dimensions)
+    }
+
+    @inlinable
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        let dimensions = try container.decode([Int].self)
+        self.init(dimensions)
+    }
+}
+
+extension TensorShape: CustomStringConvertible {
+    public var description: String {
+      return dimensions.description
+    }
+}
diff --git a/Sources/TensorFlow/Core/Threading.swift b/Sources/TensorFlow/Core/Threading.swift
new file mode 100644
index 000000000..9c19b7bc6
--- /dev/null
+++ b/Sources/TensorFlow/Core/Threading.swift
@@ -0,0 +1,73 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+import Darwin
+#else
+import Glibc
+#endif
+
+// A thread that runs the provided body.
+class Thread {
+    var thread: pthread_t
+    init(perform body: @escaping () -> ()) {
+        class ThreadArg {
+        var body : () -> ()
+            init(body : @escaping () -> ()) {
+                self.body = body
+            }
+        }
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+        typealias ThreadBody = @convention(c) (UnsafeMutableRawPointer) -> UnsafeMutableRawPointer?
+#else
+        typealias ThreadBody = @convention(c) (UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer?
+#endif
+        let threadBody: ThreadBody = { arg in
+            // Set the cancelability of the detached thread.
+            pthread_setcanceltype(Int32(PTHREAD_CANCEL_DEFERRED), nil)
+            // Execute the tensor computation.
+#if !(os(macOS) || os(iOS) || os(watchOS) || os(tvOS))
+            let arg = arg!
+#endif
+            let param: ThreadArg = Unmanaged.fromOpaque(arg).takeRetainedValue()
+            param.body()
+            return nil
+        }
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+        var newThread: pthread_t!
+#else
+        var newThread = pthread_t()
+#endif
+        let creationStatus = pthread_create(
+            &newThread, nil, threadBody,
+            Unmanaged.passRetained(ThreadArg(body: body)).toOpaque())
+        internalConsistencyCheck(creationStatus == 0)
+        self.thread = newThread
+    }
+    func join() {
+        internalConsistencyCheck(pthread_join(thread, nil) == 0)
+    }
+}
+
+public func _runOnNDevices(_ n: Int, perform body: @escaping (Int) -> ()) {
+    var threads = [] as [Thread]
+    for i in 0..<n {
+        threads.append(Thread {
+            body(i)
+        })
+    }
+    for t in threads {
+        t.join()
+    }
+}
diff --git a/Sources/TensorFlow/Core/Utilities.swift b/Sources/TensorFlow/Core/Utilities.swift
new file mode 100644
index 000000000..0f6c4c500
--- /dev/null
+++ b/Sources/TensorFlow/Core/Utilities.swift
@@ -0,0 +1,179 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+import Darwin
+#else
+import Glibc
+#endif
+
+import CTensorFlow
+
+//===------------------------------------------------------------------------------------------===//
+// Runtime Checkers
+//===------------------------------------------------------------------------------------------===//
+
+/// These checks run in both debug and release modes (while assert() only runs in debug mode), to 
+/// help shake out more bugs and facilitate debugging in the early project phases. It can be
+/// replaced with plain assert() later, when we have a more mature code base.
+@inlinable
+public func internalConsistencyCheck(
+    _ predicate: Bool,
+    _ errMessage: String = "TF runtime assertion failure",
+    file: StaticString = #file,
+    line: UInt = #line
+) {
+    guard predicate else {
+        fatalError(errMessage, file: file, line: line)
+    }
+}
+
+@inlinable
+public func checkOk(
+    _ s: CTFStatus?,
+    file: StaticString = #file,
+    line: UInt = #line
+) {
+    internalConsistencyCheck(
+        TF_GetCode(s) == TF_OK,
+        String(cString: TF_Message(s)),
+        file: file,
+        line: line)
+}
+
+//===------------------------------------------------------------------------------------------===//
+// Type Aliases
+//===------------------------------------------------------------------------------------------===//
+
+// Before assigning a C pointer to one of the pointer type aliases below, caller should check that 
+// the pointer is not NULL.
+
+/// The `TF_Session *` type.
+public typealias CTFSession = OpaquePointer
+
+/// The `TF_Status *` type.
+public typealias CTFStatus = OpaquePointer
+
+/// The `TF_Graph*` type.
+public typealias CTFGraph = OpaquePointer
+
+/// The `TF_Function*` type.
+public typealias CTFFunction = OpaquePointer
+
+/// The `TF_Tensor *` type.
+public typealias CTensor = OpaquePointer
+
+/// The `TF_TensorHandle *` type.
+///
+/// - Note: This is public so that compiler generated code can read/write tensor handles when
+///   calling runtime APIs.
+public typealias CTensorHandle = OpaquePointer
+
+/// The `TFE_Context *` type.
+public typealias CTFEContext = OpaquePointer
+
+/// The `TFE_Op *` type.
+public typealias CTFEOp = OpaquePointer
+
+/// The `TF_OperationDescription *` type.
+public typealias CTFOperationDescription = OpaquePointer
+
+/// The `TFE_TraceContext *` type.
+public typealias CTFETraceContext = OpaquePointer
+
+//===------------------------------------------------------------------------------------------===//
+// Logging
+//===------------------------------------------------------------------------------------------===//
+
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+@usableFromInline let stderr = __stderrp
+@usableFromInline let stdout = __stdoutp
+#endif
+
+/// Log to standard error.
+public func logToStderr(_ message: StaticString) {
+    message.utf8Start.withMemoryRebound(to: Int8.self, capacity: message.utf8CodeUnitCount) {
+        _ = fputs($0, stderr)
+    }
+}
+
+/// Log to standard error.
+public func logToStderr(_ message: String) {
+    _ = fputs(message, stderr)
+}
+
+@inlinable
+public func debugLog(
+    _ message: @autoclosure () -> String,
+    file: StaticString = #file,
+    line: UInt = #line
+) {
+    if _RuntimeConfig.printsDebugLog {
+        print("[\(file):\(line)] \(message())")
+        // This helps dump more log before a crash.
+        fflush(stdout)
+    }
+}
+
+//===------------------------------------------------------------------------------------------===//
+// File Writing
+//===------------------------------------------------------------------------------------------===//
+
+/// Given the address of a `TF_Buffer` and a file path, write the buffer's contents to the file.
+public func writeContents(of buffer: UnsafePointer<TF_Buffer>, toFile path: String) {
+    let fp = fopen(path, "w+")
+    fwrite(buffer.pointee.data, /*size*/ 1, /*count*/ buffer.pointee.length, fp)
+    fclose(fp)
+}
+
+//===------------------------------------------------------------------------------------------===//
+// Unit Test Utilities
+//===------------------------------------------------------------------------------------------===//
+// TODO: Move this section to a unit-test only Swift module, once the google internal lit based test 
+// infra can handle importing additional Swift modules.
+
+/// This is a generic host-only op that hides the details of its impl in the SIL code. This makes 
+/// reading/writing SIL based compiler unit tests simple.
+@inline(never)
+public func _hostOp<T>(_ x: T) {
+    print(x)
+}
+
+@inline(never)
+public func _hostOp<Scalar>(_ x: Tensor<Scalar>) {
+    print(x)
+}
+
+@inline(never)
+public func _hostOp<Scalar : TensorFlowScalar>(_ x: TensorHandle<Scalar>) {
+    print(Tensor(handle: x))
+}
+
+/// Some TPU ops (e.g. infeed/outfeed) require tensor shape info, which the APIs below can provide.
+///
+/// TODO: Remove these helper APIs, when we have a better shape inference/propagation design.
+@inlinable @inline(__always)
+public func _scalarTensorWithShape<Scalar: TensorFlowScalar>(
+    _ x: Tensor<Scalar>
+) -> Tensor<Scalar> {
+    return Raw.identity(x)
+}
+
+@inlinable @inline(__always)
+public func _addScalarTensorsWithShape<Scalar: TensorFlowNumeric>(
+    _ x: Tensor<Scalar>,
+    _ y: Tensor<Scalar>
+) -> Tensor<Scalar> {
+    return Raw.add(x, y)
+}
diff --git a/Sources/DeepLearning/Initializers.swift b/Sources/TensorFlow/Initializers.swift
similarity index 99%
rename from Sources/DeepLearning/Initializers.swift
rename to Sources/TensorFlow/Initializers.swift
index 073af0e12..bd39ce211 100644
--- a/Sources/DeepLearning/Initializers.swift
+++ b/Sources/TensorFlow/Initializers.swift
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 public extension Tensor {
     /// Creates a tensor with the specified shape and a single, repeated scalar
     /// value.
diff --git a/Sources/DeepLearning/Layer.swift b/Sources/TensorFlow/Layer.swift
similarity index 100%
rename from Sources/DeepLearning/Layer.swift
rename to Sources/TensorFlow/Layer.swift
diff --git a/Sources/DeepLearning/Loss.swift b/Sources/TensorFlow/Loss.swift
similarity index 99%
rename from Sources/DeepLearning/Loss.swift
rename to Sources/TensorFlow/Loss.swift
index fd48febda..a3c61b219 100644
--- a/Sources/DeepLearning/Loss.swift
+++ b/Sources/TensorFlow/Loss.swift
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 /// Computes the mean squared error between predictions and labels.
 ///
 /// - Parameters:
diff --git a/Sources/DeepLearning/Operators/Basic.swift b/Sources/TensorFlow/Operators/Basic.swift
similarity index 98%
rename from Sources/DeepLearning/Operators/Basic.swift
rename to Sources/TensorFlow/Operators/Basic.swift
index cfb0b4230..43aadcdd1 100644
--- a/Sources/DeepLearning/Operators/Basic.swift
+++ b/Sources/TensorFlow/Operators/Basic.swift
@@ -12,10 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 infix operator .!=: ComparisonPrecedence
 
+/// Returns a tensor with the same shape and scalars as the specified tensor.
+@inlinable
+@differentiable
+public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> {
+    return x
+}
+
 //===------------------------------------------------------------------------------------------===//
 // Shape Transformations
 //===------------------------------------------------------------------------------------------===//
@@ -578,12 +583,12 @@ public extension PartialRangeThrough where Bound == Int {
 
 public extension Tensor {
     @_fixed_layout @usableFromInline
-    internal struct IndexPath: Differentiable {
+    internal struct IndexPath {
         @usableFromInline
-        @noDerivative let begin, end, strides: Tensor<Int32>
+        let begin, end, strides: Tensor<Int32>
 
         @usableFromInline
-        @noDerivative let beginMask, endMask, ellipsisMask, newAxisMask, squeezeAxisMask: Int64
+        let beginMask, endMask, ellipsisMask, newAxisMask, squeezeAxisMask: Int64
 
         @inlinable
         public init(
@@ -628,10 +633,10 @@ public extension Tensor {
     @differentiable(wrt: self)
     subscript(_ ranges: TensorRangeExpression...) -> Tensor {
         get {
-            return self[IndexPath({ranges.map { $0.tensorRange }}()).withoutDerivative()]
+            return self[{IndexPath({ranges.map { $0.tensorRange }}())}()]
         }
         set {
-            self[IndexPath({ranges.map { $0.tensorRange }}()).withoutDerivative()] = newValue
+            self[{IndexPath({ranges.map { $0.tensorRange }}())}()] = newValue
         }
     }
 
diff --git a/Sources/DeepLearning/Operators/Comparison.swift b/Sources/TensorFlow/Operators/Comparison.swift
similarity index 99%
rename from Sources/DeepLearning/Operators/Comparison.swift
rename to Sources/TensorFlow/Operators/Comparison.swift
index 9fd7b4831..0ed6c7112 100644
--- a/Sources/DeepLearning/Operators/Comparison.swift
+++ b/Sources/TensorFlow/Operators/Comparison.swift
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 infix operator .<: ComparisonPrecedence
 infix operator .<=: ComparisonPrecedence
 infix operator .>=: ComparisonPrecedence
diff --git a/Sources/DeepLearning/Operators/Dataset.swift b/Sources/TensorFlow/Operators/Dataset.swift
similarity index 99%
rename from Sources/DeepLearning/Operators/Dataset.swift
rename to Sources/TensorFlow/Operators/Dataset.swift
index 46ae73b5c..5f66e7c78 100644
--- a/Sources/DeepLearning/Operators/Dataset.swift
+++ b/Sources/TensorFlow/Operators/Dataset.swift
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 /// The default graph seed.
 ///
 /// - Note: See TensorFlow's `python.framework.random_seed.DEFAULT_GRAPH_SEED`.
diff --git a/Sources/DeepLearning/Operators/Math.swift b/Sources/TensorFlow/Operators/Math.swift
similarity index 99%
rename from Sources/DeepLearning/Operators/Math.swift
rename to Sources/TensorFlow/Operators/Math.swift
index 075c79d92..f54a0cce9 100644
--- a/Sources/DeepLearning/Operators/Math.swift
+++ b/Sources/TensorFlow/Operators/Math.swift
@@ -12,11 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 infix operator .>: ComparisonPrecedence
 infix operator .==: ComparisonPrecedence
 
+// `pow` is defined in Darwin/Glibc on `Float` and `Double`, but there doesn't exist a generic
+// version for `FloatingPoint`.
+// This is a manual definition.
+@inlinable
+func pow<T: BinaryFloatingPoint>(_ x: T, _ y: T) -> T {
+    return T(pow(Double(x), Double(y)))
+}
+
 // TODO:
 // - Consider explicit broadcasting for elementwise binary ops when
 //   scalarization and rank getter are implemented.
diff --git a/Sources/DeepLearning/Operators/NN.swift b/Sources/TensorFlow/Operators/NN.swift
similarity index 99%
rename from Sources/DeepLearning/Operators/NN.swift
rename to Sources/TensorFlow/Operators/NN.swift
index 8002eccba..185238d0c 100644
--- a/Sources/DeepLearning/Operators/NN.swift
+++ b/Sources/TensorFlow/Operators/NN.swift
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import TensorFlowCore
-
 //===------------------------------------------------------------------------------------------===//
 // Normalization
 //===------------------------------------------------------------------------------------------===//
diff --git a/Sources/DeepLearning/Optimizer.swift b/Sources/TensorFlow/Optimizer.swift
similarity index 100%
rename from Sources/DeepLearning/Optimizer.swift
rename to Sources/TensorFlow/Optimizer.swift
diff --git a/Sources/DeepLearning/Random.swift b/Sources/TensorFlow/Random.swift
similarity index 99%
rename from Sources/DeepLearning/Random.swift
rename to Sources/TensorFlow/Random.swift
index 99906a8be..ea0783f1d 100644
--- a/Sources/DeepLearning/Random.swift
+++ b/Sources/TensorFlow/Random.swift
@@ -18,8 +18,6 @@ import Darwin
 import Glibc
 #endif
 
-import TensorFlowCore
-
 //===------------------------------------------------------------------------------------------===//
 // Random Number Generators
 //===------------------------------------------------------------------------------------------===//
diff --git a/Tests/LinuxMain.swift b/Tests/LinuxMain.swift
index 80446fe8b..1920c5f8e 100644
--- a/Tests/LinuxMain.swift
+++ b/Tests/LinuxMain.swift
@@ -1,7 +1,7 @@
 import XCTest
 
-import DeepLearningTests
+import TensorFlowTests
 
 var tests = [XCTestCaseEntry]()
-tests += DeepLearningTests.allTests()
+tests += TensorFlowTests.allTests()
 XCTMain(tests)
diff --git a/Tests/DeepLearningTests/ContextTests.swift b/Tests/TensorFlowTests/ContextTests.swift
similarity index 98%
rename from Tests/DeepLearningTests/ContextTests.swift
rename to Tests/TensorFlowTests/ContextTests.swift
index 89748cd42..20e75ff30 100644
--- a/Tests/DeepLearningTests/ContextTests.swift
+++ b/Tests/TensorFlowTests/ContextTests.swift
@@ -14,7 +14,7 @@
 
 import XCTest
 import Dispatch
-@testable import DeepLearning
+@testable import TensorFlow
 
 final class ContextTests: XCTestCase {
     func testDropout() {
diff --git a/Tests/DeepLearningTests/InitializerTests.swift b/Tests/TensorFlowTests/InitializerTests.swift
similarity index 99%
rename from Tests/DeepLearningTests/InitializerTests.swift
rename to Tests/TensorFlowTests/InitializerTests.swift
index ced975f98..83eb0807f 100644
--- a/Tests/DeepLearningTests/InitializerTests.swift
+++ b/Tests/TensorFlowTests/InitializerTests.swift
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import XCTest
-@testable import DeepLearning
+@testable import TensorFlow
 
 final class InitializerTests: XCTestCase {
     func testInitializers() {
diff --git a/Tests/DeepLearningTests/LayerTests.swift b/Tests/TensorFlowTests/LayerTests.swift
similarity index 99%
rename from Tests/DeepLearningTests/LayerTests.swift
rename to Tests/TensorFlowTests/LayerTests.swift
index 2450020cd..f93b09b79 100644
--- a/Tests/DeepLearningTests/LayerTests.swift
+++ b/Tests/TensorFlowTests/LayerTests.swift
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import XCTest
-@testable import DeepLearning
+@testable import TensorFlow
 
 final class LayerTests: XCTestCase {
     func testConv1D() {
diff --git a/Tests/DeepLearningTests/LossTests.swift b/Tests/TensorFlowTests/LossTests.swift
similarity index 99%
rename from Tests/DeepLearningTests/LossTests.swift
rename to Tests/TensorFlowTests/LossTests.swift
index d0f6570d5..7832f1b83 100644
--- a/Tests/DeepLearningTests/LossTests.swift
+++ b/Tests/TensorFlowTests/LossTests.swift
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import XCTest
-@testable import DeepLearning
+@testable import TensorFlow
 
 final class LossTests: XCTestCase {
     func testMeanSquaredErrorLoss() {
diff --git a/Tests/DeepLearningTests/OperatorTests/BasicTests.swift b/Tests/TensorFlowTests/OperatorTests/BasicTests.swift
similarity index 99%
rename from Tests/DeepLearningTests/OperatorTests/BasicTests.swift
rename to Tests/TensorFlowTests/OperatorTests/BasicTests.swift
index a0a4edbad..c5201ea7c 100644
--- a/Tests/DeepLearningTests/OperatorTests/BasicTests.swift
+++ b/Tests/TensorFlowTests/OperatorTests/BasicTests.swift
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import XCTest
-@testable import DeepLearning
+@testable import TensorFlow
 
 final class BasicOperatorTests: XCTestCase {
     func testElementIndexing() {
diff --git a/Tests/DeepLearningTests/OperatorTests/ComparisonTests.swift b/Tests/TensorFlowTests/OperatorTests/ComparisonTests.swift
similarity index 97%
rename from Tests/DeepLearningTests/OperatorTests/ComparisonTests.swift
rename to Tests/TensorFlowTests/OperatorTests/ComparisonTests.swift
index e20a9cdc9..be0831cc4 100644
--- a/Tests/DeepLearningTests/OperatorTests/ComparisonTests.swift
+++ b/Tests/TensorFlowTests/OperatorTests/ComparisonTests.swift
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import XCTest
-@testable import DeepLearning
+@testable import TensorFlow
 
 final class ComparisonOperatorTests: XCTestCase {
     func testElementwiseComparison() {
diff --git a/Tests/DeepLearningTests/OperatorTests/MathTests.swift b/Tests/TensorFlowTests/OperatorTests/MathTests.swift
similarity index 99%
rename from Tests/DeepLearningTests/OperatorTests/MathTests.swift
rename to Tests/TensorFlowTests/OperatorTests/MathTests.swift
index 5ba18b569..9f9a19976 100644
--- a/Tests/DeepLearningTests/OperatorTests/MathTests.swift
+++ b/Tests/TensorFlowTests/OperatorTests/MathTests.swift
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import XCTest
-@testable import DeepLearning
+@testable import TensorFlow
 
 final class MathOperatorTests: XCTestCase {
     func testReduction() {
diff --git a/Tests/DeepLearningTests/PRNGTests.swift b/Tests/TensorFlowTests/PRNGTests.swift
similarity index 99%
rename from Tests/DeepLearningTests/PRNGTests.swift
rename to Tests/TensorFlowTests/PRNGTests.swift
index 5031a2d1c..1e010a4e1 100644
--- a/Tests/DeepLearningTests/PRNGTests.swift
+++ b/Tests/TensorFlowTests/PRNGTests.swift
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import XCTest
-@testable import DeepLearning
+@testable import TensorFlow
 
 final class PRNGTests: XCTestCase {
     func testARC4() {
diff --git a/Tests/DeepLearningTests/SequentialTests.swift b/Tests/TensorFlowTests/SequentialTests.swift
similarity index 98%
rename from Tests/DeepLearningTests/SequentialTests.swift
rename to Tests/TensorFlowTests/SequentialTests.swift
index e6b1d62d8..1fe2fa9c0 100644
--- a/Tests/DeepLearningTests/SequentialTests.swift
+++ b/Tests/TensorFlowTests/SequentialTests.swift
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import XCTest
-@testable import DeepLearning
+@testable import TensorFlow
 
 final class SequentialTests: XCTestCase {
     func testSequential() {
diff --git a/Tests/DeepLearningTests/TensorTests.swift b/Tests/TensorFlowTests/TensorTests.swift
similarity index 98%
rename from Tests/DeepLearningTests/TensorTests.swift
rename to Tests/TensorFlowTests/TensorTests.swift
index 03218f995..30c0e9699 100644
--- a/Tests/DeepLearningTests/TensorTests.swift
+++ b/Tests/TensorFlowTests/TensorTests.swift
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import XCTest
-@testable import DeepLearning
+@testable import TensorFlow
 
 final class TensorTests: XCTestCase {
     func testSimpleCond() {
diff --git a/Tests/DeepLearningTests/TrivialModelTests.swift b/Tests/TensorFlowTests/TrivialModelTests.swift
similarity index 98%
rename from Tests/DeepLearningTests/TrivialModelTests.swift
rename to Tests/TensorFlowTests/TrivialModelTests.swift
index f24c6006c..330ac1551 100644
--- a/Tests/DeepLearningTests/TrivialModelTests.swift
+++ b/Tests/TensorFlowTests/TrivialModelTests.swift
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import XCTest
-@testable import DeepLearning
+@testable import TensorFlow
 
 final class TrivialModelTests: XCTestCase {
     func testXOR() {
diff --git a/Tests/DeepLearningTests/XCTestManifests.swift b/Tests/TensorFlowTests/XCTestManifests.swift
similarity index 100%
rename from Tests/DeepLearningTests/XCTestManifests.swift
rename to Tests/TensorFlowTests/XCTestManifests.swift

From 2e287fab5b4670d0f35ca94de9cb2b53bbb8f5ae Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Fri, 3 May 2019 00:41:08 -0400
Subject: [PATCH 19/55] Made the utility and runtime types and functions
 internal.

---
 Sources/TensorFlow/Core/Utilities.swift | 75 +++++++++++++++----------
 1 file changed, 44 insertions(+), 31 deletions(-)

diff --git a/Sources/TensorFlow/Core/Utilities.swift b/Sources/TensorFlow/Core/Utilities.swift
index 0f6c4c500..2723ba4bb 100644
--- a/Sources/TensorFlow/Core/Utilities.swift
+++ b/Sources/TensorFlow/Core/Utilities.swift
@@ -27,8 +27,8 @@ import CTensorFlow
 /// These checks run in both debug and release modes (while assert() only runs in debug mode), to 
 /// help shake out more bugs and facilitate debugging in the early project phases. It can be
 /// replaced with plain assert() later, when we have a more mature code base.
-@inlinable
-public func internalConsistencyCheck(
+@usableFromInline
+internal func internalConsistencyCheck(
     _ predicate: Bool,
     _ errMessage: String = "TF runtime assertion failure",
     file: StaticString = #file,
@@ -39,8 +39,8 @@ public func internalConsistencyCheck(
     }
 }
 
-@inlinable
-public func checkOk(
+@usableFromInline
+internal func checkOk(
     _ s: CTFStatus?,
     file: StaticString = #file,
     line: UInt = #line
@@ -60,61 +60,73 @@ public func checkOk(
 // the pointer is not NULL.
 
 /// The `TF_Session *` type.
-public typealias CTFSession = OpaquePointer
+@usableFromInline
+internal typealias CTFSession = OpaquePointer
 
 /// The `TF_Status *` type.
-public typealias CTFStatus = OpaquePointer
+@usableFromInline
+internal typealias CTFStatus = OpaquePointer
 
 /// The `TF_Graph*` type.
-public typealias CTFGraph = OpaquePointer
+@usableFromInline
+internal typealias CTFGraph = OpaquePointer
 
 /// The `TF_Function*` type.
-public typealias CTFFunction = OpaquePointer
+@usableFromInline
+internal typealias CTFFunction = OpaquePointer
 
 /// The `TF_Tensor *` type.
-public typealias CTensor = OpaquePointer
+@usableFromInline
+internal typealias CTensor = OpaquePointer
 
 /// The `TF_TensorHandle *` type.
 ///
 /// - Note: This is public so that compiler generated code can read/write tensor handles when
 ///   calling runtime APIs.
-public typealias CTensorHandle = OpaquePointer
+@usableFromInline
+internal typealias CTensorHandle = OpaquePointer
 
 /// The `TFE_Context *` type.
-public typealias CTFEContext = OpaquePointer
+@usableFromInline
+internal typealias CTFEContext = OpaquePointer
 
 /// The `TFE_Op *` type.
-public typealias CTFEOp = OpaquePointer
+@usableFromInline
+internal typealias CTFEOp = OpaquePointer
 
 /// The `TF_OperationDescription *` type.
-public typealias CTFOperationDescription = OpaquePointer
+@usableFromInline
+internal typealias CTFOperationDescription = OpaquePointer
 
 /// The `TFE_TraceContext *` type.
-public typealias CTFETraceContext = OpaquePointer
+@usableFromInline
+internal typealias CTFETraceContext = OpaquePointer
 
 //===------------------------------------------------------------------------------------------===//
 // Logging
 //===------------------------------------------------------------------------------------------===//
 
 #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
-@usableFromInline let stderr = __stderrp
-@usableFromInline let stdout = __stdoutp
+@usableFromInline internal let stderr = __stderrp
+@usableFromInline internal  let stdout = __stdoutp
 #endif
 
 /// Log to standard error.
-public func logToStderr(_ message: StaticString) {
+@usableFromInline
+internal func logToStderr(_ message: StaticString) {
     message.utf8Start.withMemoryRebound(to: Int8.self, capacity: message.utf8CodeUnitCount) {
         _ = fputs($0, stderr)
     }
 }
 
 /// Log to standard error.
-public func logToStderr(_ message: String) {
+@usableFromInline
+internal func logToStderr(_ message: String) {
     _ = fputs(message, stderr)
 }
 
-@inlinable
-public func debugLog(
+@usableFromInline
+internal func debugLog(
     _ message: @autoclosure () -> String,
     file: StaticString = #file,
     line: UInt = #line
@@ -131,7 +143,8 @@ public func debugLog(
 //===------------------------------------------------------------------------------------------===//
 
 /// Given the address of a `TF_Buffer` and a file path, write the buffer's contents to the file.
-public func writeContents(of buffer: UnsafePointer<TF_Buffer>, toFile path: String) {
+@usableFromInline
+internal func writeContents(of buffer: UnsafePointer<TF_Buffer>, toFile path: String) {
     let fp = fopen(path, "w+")
     fwrite(buffer.pointee.data, /*size*/ 1, /*count*/ buffer.pointee.length, fp)
     fclose(fp)
@@ -145,33 +158,33 @@ public func writeContents(of buffer: UnsafePointer<TF_Buffer>, toFile path: Stri
 
 /// This is a generic host-only op that hides the details of its impl in the SIL code. This makes 
 /// reading/writing SIL based compiler unit tests simple.
-@inline(never)
-public func _hostOp<T>(_ x: T) {
+@usableFromInline @inline(never)
+internal func _hostOp<T>(_ x: T) {
     print(x)
 }
 
-@inline(never)
-public func _hostOp<Scalar>(_ x: Tensor<Scalar>) {
+@usableFromInline @inline(never)
+internal func _hostOp<Scalar>(_ x: Tensor<Scalar>) {
     print(x)
 }
 
-@inline(never)
-public func _hostOp<Scalar : TensorFlowScalar>(_ x: TensorHandle<Scalar>) {
+@usableFromInline @inline(never)
+internal func _hostOp<Scalar : TensorFlowScalar>(_ x: TensorHandle<Scalar>) {
     print(Tensor(handle: x))
 }
 
 /// Some TPU ops (e.g. infeed/outfeed) require tensor shape info, which the APIs below can provide.
 ///
 /// TODO: Remove these helper APIs, when we have a better shape inference/propagation design.
-@inlinable @inline(__always)
-public func _scalarTensorWithShape<Scalar: TensorFlowScalar>(
+@usableFromInline @inline(__always)
+internal func _scalarTensorWithShape<Scalar: TensorFlowScalar>(
     _ x: Tensor<Scalar>
 ) -> Tensor<Scalar> {
     return Raw.identity(x)
 }
 
-@inlinable @inline(__always)
-public func _addScalarTensorsWithShape<Scalar: TensorFlowNumeric>(
+@usableFromInline @inline(__always)
+internal func _addScalarTensorsWithShape<Scalar: TensorFlowNumeric>(
     _ x: Tensor<Scalar>,
     _ y: Tensor<Scalar>
 ) -> Tensor<Scalar> {

From fde0a3203ca9fa41edd81aa393b847a7abef8c39 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Fri, 3 May 2019 00:43:11 -0400
Subject: [PATCH 20/55] Made the utility and runtime types and functions
 internal.

---
 Sources/TensorFlow/Core/Runtime.swift | 29 ++++++++++++++-------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index 6fccfecbd..fdf53479e 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -1617,9 +1617,9 @@ public func _TFCEagerExecute(_ op: CTFEOp,
 ///   - tensorArgumentCount: The number of tensor arguments to pass in.
 ///   - helperFunctionCount: The number of helper functions to run.
 ///   - resultCount: The number of output tensors.
-@inlinable
+@usableFromInline
 @_silgen_name("_swift_tfc_StartTensorComputation")
-public func _TFCStartTensorComputation(
+internal func _TFCStartTensorComputation(
   _ programByteAddress: UnsafeRawPointer,
   _ programByteCount: Int,
   _ entryFunctionBaseNameAddress: UnsafePointer<Int8>,
@@ -1660,9 +1660,9 @@ public func _TFCStartTensorComputation(
 /// - Note: The result address as passed in is pointing to uninitialized memory,
 ///   this must initialize the memory, transferring ownership of the tensor
 ///   handles to the caller.
-@inlinable
+@usableFromInline
 @_silgen_name("_swift_tfc_FinishTensorComputation")
-public func _TFCFinishTensorComputation(
+internal func _TFCFinishTensorComputation(
   _ computation: _TensorComputation,
   _ tensorResultAddress: UnsafeMutablePointer<CTensorHandle>,
   _ tensorResultCount: Int
@@ -1679,9 +1679,9 @@ public func _TFCFinishTensorComputation(
 /// - Parameters:
 ///   - program: The tensor program to terminate.
 /// - Note: If the execution was synchronous, then this function does nothing.
-@inlinable
+@usableFromInline
 @_silgen_name("_swift_tfc_TerminateTensorComputation")
-public func _TFCTerminateTensorComputation(_ computation: _TensorComputation) {
+internal func _TFCTerminateTensorComputation(_ computation: _TensorComputation) {
   computation.terminate()
 }
 
@@ -1690,9 +1690,9 @@ public func _TFCTerminateTensorComputation(_ computation: _TensorComputation) {
 /// - Parameters:
 ///   - programByteAddress: The address of the raw program.
 ///   - programByteCount: The number of bytes in the program.
-@inlinable
+@usableFromInline
 @_silgen_name("_swift_tfc_RegisterTensorFunctions")
-public func _TFCRegisterTensorFunctions(
+internal func _TFCRegisterTensorFunctions(
   _ programByteAddress: UnsafeRawPointer,
   _ programByteCount: Int
 ) {
@@ -1711,10 +1711,10 @@ public func _TFCRegisterTensorFunctions(
 /// - TODO(rxwei): Constrain T to _TensorFlowDataTypeCompatible and remove the
 ///   precondition. This requires the compiler to emit a call to the generic
 ///   function.
-@inlinable
+@usableFromInline
 @_silgen_name("_swift_tfc_CreateCTensorHandle")
-public func _TFCCreateCTensorHandle<T>(_ value: T,
-                                       _ dtype: TF_DataType) -> CTensorHandle {
+internal func _TFCCreateCTensorHandle<T>(_ value: T,
+                                         _ dtype: TF_DataType) -> CTensorHandle {
   // Create a new CTensor and initialize it to the scalar value.
   let tensor = TF_AllocateTensor(dtype, nil, 0, MemoryLayout<T>.stride)
   TF_TensorData(tensor).assumingMemoryBound(to: T.self).initialize(to: value)
@@ -1817,16 +1817,17 @@ func _TFCDeallocateCHandleBuffer(
 }
 
 /// Returns the number of CTensorHandles in a TensorGroup of type T.
+@usableFromInline
 @_silgen_name("_swift_tfc_GetTensorGroupCHandleCount")
-public func _TFCGetTensorGroupCHandleCount<T : TensorGroup>(
+internal func _TFCGetTensorGroupCHandleCount<T : TensorGroup>(
     _ type: T.Type
 ) -> Int32 {
   return T._tensorHandleCount
 }
 
-@inlinable
+@usableFromInline
 @_silgen_name("_swift_tfc_CreateTensorHandleFromC")
-public func _TFCCreateTensorHandleFromC(
+internal func _TFCCreateTensorHandleFromC(
   _ cHandle: CTensorHandle
 ) -> _AnyTensorHandle {
   let dtype = TFE_TensorHandleDataType(cHandle)

From f0a693a4d6c94553e838cfa446af30547f7ed36f Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Fri, 3 May 2019 20:46:09 -0400
Subject: [PATCH 21/55] Visibility fixes.

---
 Sources/TensorFlow/Core/Execution.swift    |  6 +++---
 Sources/TensorFlow/Core/Runtime.swift      | 13 +++++++------
 Sources/TensorFlow/Core/TensorHandle.swift |  4 ++--
 Sources/TensorFlow/Core/Utilities.swift    |  3 +--
 4 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/Sources/TensorFlow/Core/Execution.swift b/Sources/TensorFlow/Core/Execution.swift
index b2c36fa20..679a27543 100644
--- a/Sources/TensorFlow/Core/Execution.swift
+++ b/Sources/TensorFlow/Core/Execution.swift
@@ -17,23 +17,23 @@
 // FIXME: We need transparent here because deabstraction isn't inlining this function.  We need to 
 // inline if a callee contains tensor ops, not only if it takes and returns a TensorFlow value.
 @_transparent
+@available(*, deprecated)
 public func enableTPU(serverAddress: String? = nil, infeed: Bool = true) {
     _RuntimeConfig.executionMode = .tpu
     if let serverAddress = serverAddress {
         _RuntimeConfig.session = .remote(serverDef: serverAddress)
     }
-    #tfop("tfc.configureTPU", enableInfeed: infeed) as Void
 }
 
 // FIXME: Extend the interface to support multiple GPU devices, and unify it with enableTPU() above.
 @_transparent
+@available(*, deprecated)
 public func enableGPU() {
-    #tfop("tfc.configureGPU") as Void
 }
 
 @_transparent
+@available(*, deprecated)
 public func enableCPU() {
-    #tfop("tfc.configureCPU") as Void
 }
 
 /// A TensorFlow device kind.
diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index fdf53479e..70878a215 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -633,7 +633,8 @@ public final class _ExecutionContext {
   public let tensorFlowConfig: UnsafeMutablePointer<TF_Buffer>
 
   /// The TFE_Context object.
-  public let eagerContext: CTFEContext
+  @usableFromInline
+  internal let eagerContext: CTFEContext
 
   // NOTE: the following properties are intentionally not implemented as an enum
   // due to high churn, *please do not refactor for Swiftiness*.
@@ -1536,7 +1537,7 @@ private extension _TensorComputation {
   }
 }
 
-public extension _TensorComputation {
+internal extension _TensorComputation {
   /// Terminates the computation, and clean up the state.
   func terminate() {
     for pthread in pthreads {
@@ -1575,10 +1576,10 @@ public extension _TensorComputation {
 
 @inlinable
 @_cdecl("_swift_tfc_EagerExecute")
-public func _TFCEagerExecute(_ op: CTFEOp,
-                             _ retvals: UnsafeMutablePointer<OpaquePointer?>,
-                             _ retvalCount: UnsafeMutablePointer<Int32>,
-                             _ status: CTFStatus) {
+internal func _TFCEagerExecute(_ op: CTFEOp,
+                               _ retvals: UnsafeMutablePointer<OpaquePointer?>,
+                               _ retvalCount: UnsafeMutablePointer<Int32>,
+                               _ status: CTFStatus) {
   if _RuntimeConfig.printsDebugLog {
     debugLog("Calling _TFCEagerExecute() over: ")
     TFE_OpPrintDebugString(op)
diff --git a/Sources/TensorFlow/Core/TensorHandle.swift b/Sources/TensorFlow/Core/TensorHandle.swift
index 6a181f658..a377f01b4 100644
--- a/Sources/TensorFlow/Core/TensorHandle.swift
+++ b/Sources/TensorFlow/Core/TensorHandle.swift
@@ -41,8 +41,8 @@ public final class TensorHandle<Scalar>: _AnyTensorHandle
         super.init(base: cTensorHandle)
     }
 
-    @inlinable
-    public convenience init(copyingFromCTensor cTensor: CTensor) {
+    @usableFromInline
+    internal convenience init(copyingFromCTensor cTensor: CTensor) {
         let status = TF_NewStatus()
         let cTensorHandle = TFE_NewTensorHandle(cTensor, status)
         checkOk(status)
diff --git a/Sources/TensorFlow/Core/Utilities.swift b/Sources/TensorFlow/Core/Utilities.swift
index 2723ba4bb..7539b7d27 100644
--- a/Sources/TensorFlow/Core/Utilities.swift
+++ b/Sources/TensorFlow/Core/Utilities.swift
@@ -83,8 +83,7 @@ internal typealias CTensor = OpaquePointer
 ///
 /// - Note: This is public so that compiler generated code can read/write tensor handles when
 ///   calling runtime APIs.
-@usableFromInline
-internal typealias CTensorHandle = OpaquePointer
+public typealias CTensorHandle = OpaquePointer
 
 /// The `TFE_Context *` type.
 @usableFromInline

From 1190edb77ca4d56595c4c242393f1897891ab1e6 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sat, 11 May 2019 16:55:36 -0400
Subject: [PATCH 22/55] Merged upstream changes.

---
 Sources/TensorFlow/Core/Utilities.swift  | 15 +++++++++++++++
 Sources/TensorFlow/Operators/Basic.swift |  2 +-
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/Sources/TensorFlow/Core/Utilities.swift b/Sources/TensorFlow/Core/Utilities.swift
index 7539b7d27..5d085e534 100644
--- a/Sources/TensorFlow/Core/Utilities.swift
+++ b/Sources/TensorFlow/Core/Utilities.swift
@@ -189,3 +189,18 @@ internal func _addScalarTensorsWithShape<Scalar: TensorFlowNumeric>(
 ) -> Tensor<Scalar> {
     return Raw.add(x, y)
 }
+
+// TODO: Consider revising the call sites where this is necessary to only need UnsafeMutablePointer 
+// to optional when it is the actual c-api call site.
+extension UnsafeMutablePointer where Pointee == CTensorHandle? {
+    @usableFromInline
+    init(_ other: UnsafeMutablePointer<CTensorHandle>) {
+        self.init(other._rawValue)
+    }
+
+    @usableFromInline
+    init?(_ other: UnsafeMutablePointer<CTensorHandle>?) {
+        guard let unwrapped = other else { return nil }
+        self.init(unwrapped)
+    }
+}
diff --git a/Sources/TensorFlow/Operators/Basic.swift b/Sources/TensorFlow/Operators/Basic.swift
index 43aadcdd1..5e6a3c3ac 100644
--- a/Sources/TensorFlow/Operators/Basic.swift
+++ b/Sources/TensorFlow/Operators/Basic.swift
@@ -659,7 +659,7 @@ internal extension Tensor.IndexPath {
     @inlinable
     init(_ ranges: [TensorRange]) {
         precondition(!ranges.isEmpty, "The tensor range collection cannot be empty.")
-        precondition(ranges.count { $0 == TensorRange.ellipsis } < 2,
+        precondition(ranges.lazy.filter { $0 == TensorRange.ellipsis }.count < 2,
                      "Only one ellipsis is allowed per tensor range collection.")
 
         var begin = [Int32](repeating: 0, count: ranges.count)

From b1191700a264349f763b48b8d276b2578b166928 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sat, 11 May 2019 16:59:47 -0400
Subject: [PATCH 23/55] Added the raw op bindings.

---
 .gitignore                                    |     3 +
 .../TensorFlow/Bindings/EagerExecution.swift  |   620 +
 .../Bindings/EagerExecution.swift.gyb         |   309 +
 Sources/TensorFlow/Bindings/README.md         |    32 +
 .../TensorFlow/Bindings/RawOpsGenerated.swift | 35622 ++++++++++++++++
 .../TensorFlow/Bindings/generate_wrappers.py  |   708 +
 6 files changed, 37294 insertions(+)
 create mode 100644 Sources/TensorFlow/Bindings/EagerExecution.swift
 create mode 100644 Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
 create mode 100644 Sources/TensorFlow/Bindings/README.md
 create mode 100644 Sources/TensorFlow/Bindings/RawOpsGenerated.swift
 create mode 100644 Sources/TensorFlow/Bindings/generate_wrappers.py

diff --git a/.gitignore b/.gitignore
index c719a53ee..567f66548 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,6 @@ xcuserdata
 DerivedData/
 *.xcodeproj
 *~
+
+### MacOS ###
+.DS_Store
diff --git a/Sources/TensorFlow/Bindings/EagerExecution.swift b/Sources/TensorFlow/Bindings/EagerExecution.swift
new file mode 100644
index 000000000..7c25f2bb7
--- /dev/null
+++ b/Sources/TensorFlow/Bindings/EagerExecution.swift
@@ -0,0 +1,620 @@
+// !!! THIS CODE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND !!!
+//
+// Copyright 2018-19 Google LLC
+//
+// 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
+//
+//     https://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.
+
+import CTensorFlow
+
+/// **WARNING:** After constructing a `TFE_Op`, any one of its `execute` methods must be called
+/// *exactly once*. If not called, then a memory leak is introduced due to the underlying TensorFlow
+/// eager op object not being freed. If called more than once, then a SEGFAULT may occur due to
+/// trying to execute a TensorFlow eager op that has already been freed.
+@usableFromInline
+internal struct TFE_Op {
+  @usableFromInline internal let status: CTFStatus
+  @usableFromInline internal let op: CTFEOp
+
+  @inlinable @inline(__always)
+  internal init(_ name: String) {
+    self.status = TF_NewStatus()
+    self.op = TFE_NewOp(_ExecutionContext.global.eagerContext, name, status)
+  }
+
+  @inlinable @inline(__always)
+  internal func addInput(_ inputHandle: _AnyTensorHandle) -> Int {
+    TFE_OpAddInput(op, inputHandle._cTensorHandle, status)
+    checkOk(status)
+    return 1
+  }
+
+  @inlinable @inline(__always)
+  internal func addInput<Scalar: TensorFlowScalar>(_ input: Tensor<Scalar>) -> Int {
+    TFE_OpAddInput(op, input.handle._cTensorHandle, status)
+    checkOk(status)
+    return 1
+  }
+
+  @inlinable @inline(__always)
+  internal func addInput(_ input: StringTensor) -> Int {
+    TFE_OpAddInput(op, input.handle._cTensorHandle, status)
+    checkOk(status)
+    return 1
+  }
+
+  @inlinable @inline(__always)
+  internal func addInputList<T: TensorArrayProtocol>(_ input: T) -> Int {
+    let count = input._tensorHandleCount
+    var buffer = UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: Int(count))
+    defer { buffer.deallocate() }
+    let pointer = UnsafeMutablePointer<OpaquePointer?>(buffer.baseAddress)
+    input._unpackTensorHandles(into: buffer.baseAddress)
+    TFE_OpAddInputList(op, pointer, count, status)
+    // TODO: checkOk(status)
+    return Int(count)
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: Bool) {
+    TFE_OpSetAttrBool(op, name, value ? 1 : 0)
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: Int) {
+    TFE_OpSetAttrInt(op, name, Int64(value))
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: Int32) {
+    TFE_OpSetAttrInt(op, name, Int64(value))
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: Int64) {
+    TFE_OpSetAttrInt(op, name, value)
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: Float) {
+    TFE_OpSetAttrFloat(op, name, value)
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: Double) {
+    TFE_OpSetAttrFloat(op, name, Float(value))
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: String) {
+    value.utf8CString.withUnsafeBufferPointer { buffer in
+      // utf8CString is null-terminated; TFE_OpSetAttrString wants
+      // non-null-terminated.
+      TFE_OpSetAttrString(op, name, buffer.baseAddress, buffer.count - 1)
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: TensorDataType) {
+    TFE_OpSetAttrType(op, name, value._cDataType)
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: TensorShape) {
+    let dimensions: [Int64] = value.dimensions.map(Int64.init)
+    dimensions.withUnsafeBufferPointer { buffer in
+      TFE_OpSetAttrShape(op, name, buffer.baseAddress, Int32(buffer.count), status)
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: TensorShape?) {
+    guard let shape = value else {
+      TFE_OpSetAttrShape(op, name, nil, -1, status)
+      return
+    }
+    setAttr(name, shape)
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [Bool]) {
+    value.map({ $0 ? UInt8(1) : UInt8(0) }).withUnsafeBufferPointer { buffer in
+      TFE_OpSetAttrBoolList(op, name, buffer.baseAddress, Int32(buffer.count))
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [Int]) {
+    setAttr(name, value.map(Int64.init))
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [Int32]) {
+    setAttr(name, value.map(Int64.init))
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [Int64]) {
+    value.withUnsafeBufferPointer { buffer in
+      TFE_OpSetAttrIntList(op, name, buffer.baseAddress, Int32(buffer.count))
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [Float]) {
+    value.withUnsafeBufferPointer { buffer in
+      TFE_OpSetAttrFloatList(op, name, buffer.baseAddress, Int32(buffer.count))
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [Double]) {
+    setAttr(name, value.map(Float.init))
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [String]) {
+    // Collect all the strings' utf8 bytes into a single array so that we can
+    // address all the strings with a single
+    // `flattenedStringBytes.withUnsafeBufferPointer`.
+    var flattenedStringBytes: [CChar] = []
+    var lengths: [Int] = []
+    for string in value {
+      // Don't include the null-terminator because TFE_OpSetAttrStringList uses
+      // lengths instead of null-terminators.
+      let stringBytes = string.utf8CString.dropLast()
+      flattenedStringBytes.append(contentsOf: stringBytes)
+      lengths.append(stringBytes.count)
+    }
+
+    // Calculate the addresses of all the strings within our single buffer, and
+    // then call TFE_OpSetAttrStringList.
+    flattenedStringBytes.withUnsafeBufferPointer { flattenedStringBytesBuffer in
+      var stringAddrs: [UnsafeRawPointer?] = []
+      var currentStringAddr =
+        flattenedStringBytesBuffer.baseAddress.map(UnsafeRawPointer.init)
+      for length in lengths {
+        stringAddrs.append(currentStringAddr)
+        currentStringAddr = currentStringAddr?.advanced(by: length)
+      }
+
+      stringAddrs.withUnsafeBufferPointer { stringAddrsBuffer in
+        lengths.withUnsafeBufferPointer { lengthsBuffer in
+          TFE_OpSetAttrStringList(op, name, stringAddrsBuffer.baseAddress,
+            lengthsBuffer.baseAddress, Int32(value.count))
+        }
+      }
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [TensorDataType]) {
+    value.withUnsafeBufferPointer { buffer in
+      buffer.withMemoryRebound(to: TF_DataType.self) { reboundBuffer in
+        TFE_OpSetAttrTypeList(op, name, reboundBuffer.baseAddress, Int32(reboundBuffer.count))
+      }
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [TensorShape]) {
+    let flattenedDims = value.flatMap { $0.dimensions.map(Int64.init) }
+    let ranks = value.map { Int32($0.rank) }
+    flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
+      var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
+      var dims: [UnsafePointer<Int64>?] = []
+      for rank in ranks {
+        dims.append(dimsPtr)
+        if rank >= 0 {
+          dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
+        }
+      }
+      dims.withUnsafeMutableBufferPointer { dimsBuffer in
+        ranks.withUnsafeBufferPointer { ranksBuffer in
+          TFE_OpSetAttrShapeList(
+            op, name, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
+            Int32(ranksBuffer.count), status)
+        }
+      }
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [TensorShape?]) {
+    let flattenedDims = value.flatMap { (tensorShapeOpt) -> [Int64] in
+      if let tensorShape = tensorShapeOpt {
+        return tensorShape.dimensions.map(Int64.init)
+      }
+      return []
+    }
+    let ranks = value.map { shape in (shape?.rank).map(Int32.init) ?? -1 }
+    flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
+      var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
+      var dims: [UnsafePointer<Int64>?] = []
+      for rank in ranks {
+        dims.append(dimsPtr)
+        if rank >= 0 {
+          dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
+        }
+      }
+      dims.withUnsafeMutableBufferPointer { dimsBuffer in
+        ranks.withUnsafeBufferPointer { ranksBuffer in
+          TFE_OpSetAttrShapeList(
+            op, name, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
+            Int32(ranksBuffer.count), status)
+        }
+      }
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr<In: TensorGroup, Out: TensorGroup>(_ name: String, _ value: (In) -> Out) {
+    _tffunc(value).utf8CString.withUnsafeBufferPointer { buffer in
+      // utf8CString is null-terminated; TFE_OpSetAttrFunctionName wants
+      // non-null-terminated.
+      TFE_OpSetAttrFunctionName(op, name, buffer.baseAddress, buffer.count - 1)
+    }
+  }
+
+  /// **WARNING:** After constructing a `TFE_Op`, any one of its `execute` methods must be called
+  /// *exactly once*. If not called, then a memory leak is introduced due to the underlying
+  /// TensorFlow eager op object not being freed. If called more than once, then a SEGFAULT may
+  /// occur due to trying to execute a TensorFlow eager op that has already been freed.
+
+  @inlinable @inline(__always)
+  internal func execute() {
+    var count: Int32 = 0
+    var unused: CTensorHandle?
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, &unused, &count, status)
+    checkOk(status)
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+  }
+
+  @inlinable @inline(__always)
+  internal func execute<T0 : TensorArrayProtocol>(
+    _ count0: Int
+  ) -> (T0) {
+    var count = Int32(count0)
+    let buffer: UnsafeMutablePointer<CTensorHandle> =
+      UnsafeMutablePointer.allocate(capacity: Int(count))
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+    checkOk(status)
+    let offset0 = Int32(0)
+    let result = (
+      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0))
+    buffer.deallocate()
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+    return result
+  }
+
+  @inlinable @inline(__always)
+  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol>(
+    _ count0: Int,
+    _ count1: Int
+  ) -> (T0, T1) {
+    var count = Int32(count0) + Int32(count1)
+    let buffer: UnsafeMutablePointer<CTensorHandle> =
+      UnsafeMutablePointer.allocate(capacity: Int(count))
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+    checkOk(status)
+    let offset0 = Int32(0)
+    let offset1 = offset0 + Int32(count0)
+    let result = (
+      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1))
+    buffer.deallocate()
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+    return result
+  }
+
+  @inlinable @inline(__always)
+  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol>(
+    _ count0: Int,
+    _ count1: Int,
+    _ count2: Int
+  ) -> (T0, T1, T2) {
+    var count = Int32(count0) + Int32(count1) + Int32(count2)
+    let buffer: UnsafeMutablePointer<CTensorHandle> =
+      UnsafeMutablePointer.allocate(capacity: Int(count))
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+    checkOk(status)
+    let offset0 = Int32(0)
+    let offset1 = offset0 + Int32(count0)
+    let offset2 = offset1 + Int32(count1)
+    let result = (
+      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2))
+    buffer.deallocate()
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+    return result
+  }
+
+  @inlinable @inline(__always)
+  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol>(
+    _ count0: Int,
+    _ count1: Int,
+    _ count2: Int,
+    _ count3: Int
+  ) -> (T0, T1, T2, T3) {
+    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3)
+    let buffer: UnsafeMutablePointer<CTensorHandle> =
+      UnsafeMutablePointer.allocate(capacity: Int(count))
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+    checkOk(status)
+    let offset0 = Int32(0)
+    let offset1 = offset0 + Int32(count0)
+    let offset2 = offset1 + Int32(count1)
+    let offset3 = offset2 + Int32(count2)
+    let result = (
+      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3))
+    buffer.deallocate()
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+    return result
+  }
+
+  @inlinable @inline(__always)
+  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol>(
+    _ count0: Int,
+    _ count1: Int,
+    _ count2: Int,
+    _ count3: Int,
+    _ count4: Int
+  ) -> (T0, T1, T2, T3, T4) {
+    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3) + Int32(count4)
+    let buffer: UnsafeMutablePointer<CTensorHandle> =
+      UnsafeMutablePointer.allocate(capacity: Int(count))
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+    checkOk(status)
+    let offset0 = Int32(0)
+    let offset1 = offset0 + Int32(count0)
+    let offset2 = offset1 + Int32(count1)
+    let offset3 = offset2 + Int32(count2)
+    let offset4 = offset3 + Int32(count3)
+    let result = (
+      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
+      T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4))
+    buffer.deallocate()
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+    return result
+  }
+
+  @inlinable @inline(__always)
+  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol>(
+    _ count0: Int,
+    _ count1: Int,
+    _ count2: Int,
+    _ count3: Int,
+    _ count4: Int,
+    _ count5: Int
+  ) -> (T0, T1, T2, T3, T4, T5) {
+    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3) + Int32(count4) + Int32(count5)
+    let buffer: UnsafeMutablePointer<CTensorHandle> =
+      UnsafeMutablePointer.allocate(capacity: Int(count))
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+    checkOk(status)
+    let offset0 = Int32(0)
+    let offset1 = offset0 + Int32(count0)
+    let offset2 = offset1 + Int32(count1)
+    let offset3 = offset2 + Int32(count2)
+    let offset4 = offset3 + Int32(count3)
+    let offset5 = offset4 + Int32(count4)
+    let result = (
+      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
+      T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
+      T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5))
+    buffer.deallocate()
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+    return result
+  }
+
+  @inlinable @inline(__always)
+  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol, T6 : TensorArrayProtocol>(
+    _ count0: Int,
+    _ count1: Int,
+    _ count2: Int,
+    _ count3: Int,
+    _ count4: Int,
+    _ count5: Int,
+    _ count6: Int
+  ) -> (T0, T1, T2, T3, T4, T5, T6) {
+    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3) + Int32(count4) + Int32(count5) + Int32(count6)
+    let buffer: UnsafeMutablePointer<CTensorHandle> =
+      UnsafeMutablePointer.allocate(capacity: Int(count))
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+    checkOk(status)
+    let offset0 = Int32(0)
+    let offset1 = offset0 + Int32(count0)
+    let offset2 = offset1 + Int32(count1)
+    let offset3 = offset2 + Int32(count2)
+    let offset4 = offset3 + Int32(count3)
+    let offset5 = offset4 + Int32(count4)
+    let offset6 = offset5 + Int32(count5)
+    let result = (
+      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
+      T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
+      T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5),
+      T6.init(_owning: buffer.advanced(by: Int(offset6)), count: count6))
+    buffer.deallocate()
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+    return result
+  }
+
+  @inlinable @inline(__always)
+  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol, T6 : TensorArrayProtocol, T7 : TensorArrayProtocol>(
+    _ count0: Int,
+    _ count1: Int,
+    _ count2: Int,
+    _ count3: Int,
+    _ count4: Int,
+    _ count5: Int,
+    _ count6: Int,
+    _ count7: Int
+  ) -> (T0, T1, T2, T3, T4, T5, T6, T7) {
+    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3) + Int32(count4) + Int32(count5) + Int32(count6) + Int32(count7)
+    let buffer: UnsafeMutablePointer<CTensorHandle> =
+      UnsafeMutablePointer.allocate(capacity: Int(count))
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+    checkOk(status)
+    let offset0 = Int32(0)
+    let offset1 = offset0 + Int32(count0)
+    let offset2 = offset1 + Int32(count1)
+    let offset3 = offset2 + Int32(count2)
+    let offset4 = offset3 + Int32(count3)
+    let offset5 = offset4 + Int32(count4)
+    let offset6 = offset5 + Int32(count5)
+    let offset7 = offset6 + Int32(count6)
+    let result = (
+      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
+      T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
+      T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5),
+      T6.init(_owning: buffer.advanced(by: Int(offset6)), count: count6),
+      T7.init(_owning: buffer.advanced(by: Int(offset7)), count: count7))
+    buffer.deallocate()
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+    return result
+  }
+
+  @inlinable @inline(__always)
+  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol, T6 : TensorArrayProtocol, T7 : TensorArrayProtocol, T8 : TensorArrayProtocol>(
+    _ count0: Int,
+    _ count1: Int,
+    _ count2: Int,
+    _ count3: Int,
+    _ count4: Int,
+    _ count5: Int,
+    _ count6: Int,
+    _ count7: Int,
+    _ count8: Int
+  ) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8) {
+    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3) + Int32(count4) + Int32(count5) + Int32(count6) + Int32(count7) + Int32(count8)
+    let buffer: UnsafeMutablePointer<CTensorHandle> =
+      UnsafeMutablePointer.allocate(capacity: Int(count))
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+    checkOk(status)
+    let offset0 = Int32(0)
+    let offset1 = offset0 + Int32(count0)
+    let offset2 = offset1 + Int32(count1)
+    let offset3 = offset2 + Int32(count2)
+    let offset4 = offset3 + Int32(count3)
+    let offset5 = offset4 + Int32(count4)
+    let offset6 = offset5 + Int32(count5)
+    let offset7 = offset6 + Int32(count6)
+    let offset8 = offset7 + Int32(count7)
+    let result = (
+      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
+      T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
+      T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5),
+      T6.init(_owning: buffer.advanced(by: Int(offset6)), count: count6),
+      T7.init(_owning: buffer.advanced(by: Int(offset7)), count: count7),
+      T8.init(_owning: buffer.advanced(by: Int(offset8)), count: count8))
+    buffer.deallocate()
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+    return result
+  }
+
+  @inlinable @inline(__always)
+  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol, T6 : TensorArrayProtocol, T7 : TensorArrayProtocol, T8 : TensorArrayProtocol, T9 : TensorArrayProtocol>(
+    _ count0: Int,
+    _ count1: Int,
+    _ count2: Int,
+    _ count3: Int,
+    _ count4: Int,
+    _ count5: Int,
+    _ count6: Int,
+    _ count7: Int,
+    _ count8: Int,
+    _ count9: Int
+  ) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {
+    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3) + Int32(count4) + Int32(count5) + Int32(count6) + Int32(count7) + Int32(count8) + Int32(count9)
+    let buffer: UnsafeMutablePointer<CTensorHandle> =
+      UnsafeMutablePointer.allocate(capacity: Int(count))
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+    checkOk(status)
+    let offset0 = Int32(0)
+    let offset1 = offset0 + Int32(count0)
+    let offset2 = offset1 + Int32(count1)
+    let offset3 = offset2 + Int32(count2)
+    let offset4 = offset3 + Int32(count3)
+    let offset5 = offset4 + Int32(count4)
+    let offset6 = offset5 + Int32(count5)
+    let offset7 = offset6 + Int32(count6)
+    let offset8 = offset7 + Int32(count7)
+    let offset9 = offset8 + Int32(count8)
+    let result = (
+      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
+      T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
+      T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5),
+      T6.init(_owning: buffer.advanced(by: Int(offset6)), count: count6),
+      T7.init(_owning: buffer.advanced(by: Int(offset7)), count: count7),
+      T8.init(_owning: buffer.advanced(by: Int(offset8)), count: count8),
+      T9.init(_owning: buffer.advanced(by: Int(offset9)), count: count9))
+    buffer.deallocate()
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+    return result
+  }
+
+}
diff --git a/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb b/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
new file mode 100644
index 000000000..826f35f2c
--- /dev/null
+++ b/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
@@ -0,0 +1,309 @@
+// !!! THIS CODE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND !!!
+//
+// Copyright 2018-19 Google LLC
+//
+// 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
+//
+//     https://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.
+
+import CTensorFlow
+
+/// **WARNING:** After constructing a `TFE_Op`, any one of its `execute` methods must be called
+/// *exactly once*. If not called, then a memory leak is introduced due to the underlying TensorFlow
+/// eager op object not being freed. If called more than once, then a SEGFAULT may occur due to
+/// trying to execute a TensorFlow eager op that has already been freed.
+@usableFromInline
+internal struct TFE_Op {
+  @usableFromInline internal let status: CTFStatus
+  @usableFromInline internal let op: CTFEOp
+
+  @inlinable @inline(__always)
+  internal init(_ name: String) {
+    self.status = TF_NewStatus()
+    self.op = TFE_NewOp(_ExecutionContext.global.eagerContext, name, status)
+  }
+
+  @inlinable @inline(__always)
+  internal func addInput(_ inputHandle: _AnyTensorHandle) -> Int {
+    TFE_OpAddInput(op, inputHandle._cTensorHandle, status)
+    checkOk(status)
+    return 1
+  }
+
+  @inlinable @inline(__always)
+  internal func addInput<Scalar: TensorFlowScalar>(_ input: Tensor<Scalar>) -> Int {
+    TFE_OpAddInput(op, input.handle._cTensorHandle, status)
+    checkOk(status)
+    return 1
+  }
+
+  @inlinable @inline(__always)
+  internal func addInput(_ input: StringTensor) -> Int {
+    TFE_OpAddInput(op, input.handle._cTensorHandle, status)
+    checkOk(status)
+    return 1
+  }
+
+  @inlinable @inline(__always)
+  internal func addInputList<T: TensorArrayProtocol>(_ input: T) -> Int {
+    let count = input._tensorHandleCount
+    var buffer = UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: Int(count))
+    defer { buffer.deallocate() }
+    let pointer = UnsafeMutablePointer<OpaquePointer?>(buffer.baseAddress)
+    input._unpackTensorHandles(into: buffer.baseAddress)
+    TFE_OpAddInputList(op, pointer, count, status)
+    // TODO: checkOk(status)
+    return Int(count)
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: Bool) {
+    TFE_OpSetAttrBool(op, name, value ? 1 : 0)
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: Int) {
+    TFE_OpSetAttrInt(op, name, Int64(value))
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: Int32) {
+    TFE_OpSetAttrInt(op, name, Int64(value))
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: Int64) {
+    TFE_OpSetAttrInt(op, name, value)
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: Float) {
+    TFE_OpSetAttrFloat(op, name, value)
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: Double) {
+    TFE_OpSetAttrFloat(op, name, Float(value))
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: String) {
+    value.utf8CString.withUnsafeBufferPointer { buffer in
+      // utf8CString is null-terminated; TFE_OpSetAttrString wants
+      // non-null-terminated.
+      TFE_OpSetAttrString(op, name, buffer.baseAddress, buffer.count - 1)
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: TensorDataType) {
+    TFE_OpSetAttrType(op, name, value._cDataType)
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: TensorShape) {
+    let dimensions: [Int64] = value.dimensions.map(Int64.init)
+    dimensions.withUnsafeBufferPointer { buffer in
+      TFE_OpSetAttrShape(op, name, buffer.baseAddress, Int32(buffer.count), status)
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: TensorShape?) {
+    guard let shape = value else {
+      TFE_OpSetAttrShape(op, name, nil, -1, status)
+      return
+    }
+    setAttr(name, shape)
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [Bool]) {
+    value.map({ $0 ? UInt8(1) : UInt8(0) }).withUnsafeBufferPointer { buffer in
+      TFE_OpSetAttrBoolList(op, name, buffer.baseAddress, Int32(buffer.count))
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [Int]) {
+    setAttr(name, value.map(Int64.init))
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [Int32]) {
+    setAttr(name, value.map(Int64.init))
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [Int64]) {
+    value.withUnsafeBufferPointer { buffer in
+      TFE_OpSetAttrIntList(op, name, buffer.baseAddress, Int32(buffer.count))
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [Float]) {
+    value.withUnsafeBufferPointer { buffer in
+      TFE_OpSetAttrFloatList(op, name, buffer.baseAddress, Int32(buffer.count))
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [Double]) {
+    setAttr(name, value.map(Float.init))
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [String]) {
+    // Collect all the strings' utf8 bytes into a single array so that we can
+    // address all the strings with a single
+    // `flattenedStringBytes.withUnsafeBufferPointer`.
+    var flattenedStringBytes: [CChar] = []
+    var lengths: [Int] = []
+    for string in value {
+      // Don't include the null-terminator because TFE_OpSetAttrStringList uses
+      // lengths instead of null-terminators.
+      let stringBytes = string.utf8CString.dropLast()
+      flattenedStringBytes.append(contentsOf: stringBytes)
+      lengths.append(stringBytes.count)
+    }
+
+    // Calculate the addresses of all the strings within our single buffer, and
+    // then call TFE_OpSetAttrStringList.
+    flattenedStringBytes.withUnsafeBufferPointer { flattenedStringBytesBuffer in
+      var stringAddrs: [UnsafeRawPointer?] = []
+      var currentStringAddr =
+        flattenedStringBytesBuffer.baseAddress.map(UnsafeRawPointer.init)
+      for length in lengths {
+        stringAddrs.append(currentStringAddr)
+        currentStringAddr = currentStringAddr?.advanced(by: length)
+      }
+
+      stringAddrs.withUnsafeBufferPointer { stringAddrsBuffer in
+        lengths.withUnsafeBufferPointer { lengthsBuffer in
+          TFE_OpSetAttrStringList(op, name, stringAddrsBuffer.baseAddress,
+            lengthsBuffer.baseAddress, Int32(value.count))
+        }
+      }
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [TensorDataType]) {
+    value.withUnsafeBufferPointer { buffer in
+      buffer.withMemoryRebound(to: TF_DataType.self) { reboundBuffer in
+        TFE_OpSetAttrTypeList(op, name, reboundBuffer.baseAddress, Int32(reboundBuffer.count))
+      }
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [TensorShape]) {
+    let flattenedDims = value.flatMap { $0.dimensions.map(Int64.init) }
+    let ranks = value.map { Int32($0.rank) }
+    flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
+      var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
+      var dims: [UnsafePointer<Int64>?] = []
+      for rank in ranks {
+        dims.append(dimsPtr)
+        if rank >= 0 {
+          dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
+        }
+      }
+      dims.withUnsafeMutableBufferPointer { dimsBuffer in
+        ranks.withUnsafeBufferPointer { ranksBuffer in
+          TFE_OpSetAttrShapeList(
+            op, name, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
+            Int32(ranksBuffer.count), status)
+        }
+      }
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr(_ name: String, _ value: [TensorShape?]) {
+    let flattenedDims = value.flatMap { (tensorShapeOpt) -> [Int64] in
+      if let tensorShape = tensorShapeOpt {
+        return tensorShape.dimensions.map(Int64.init)
+      }
+      return []
+    }
+    let ranks = value.map { shape in (shape?.rank).map(Int32.init) ?? -1 }
+    flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
+      var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
+      var dims: [UnsafePointer<Int64>?] = []
+      for rank in ranks {
+        dims.append(dimsPtr)
+        if rank >= 0 {
+          dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
+        }
+      }
+      dims.withUnsafeMutableBufferPointer { dimsBuffer in
+        ranks.withUnsafeBufferPointer { ranksBuffer in
+          TFE_OpSetAttrShapeList(
+            op, name, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
+            Int32(ranksBuffer.count), status)
+        }
+      }
+    }
+  }
+
+  @inlinable @inline(__always)
+  internal func setAttr<In: TensorGroup, Out: TensorGroup>(_ name: String, _ value: (In) -> Out) {
+    _tffunc(value).utf8CString.withUnsafeBufferPointer { buffer in
+      // utf8CString is null-terminated; TFE_OpSetAttrFunctionName wants
+      // non-null-terminated.
+      TFE_OpSetAttrFunctionName(op, name, buffer.baseAddress, buffer.count - 1)
+    }
+  }
+
+  /// **WARNING:** After constructing a `TFE_Op`, any one of its `execute` methods must be called
+  /// *exactly once*. If not called, then a memory leak is introduced due to the underlying
+  /// TensorFlow eager op object not being freed. If called more than once, then a SEGFAULT may
+  /// occur due to trying to execute a TensorFlow eager op that has already been freed.
+
+  @inlinable @inline(__always)
+  internal func execute() {
+    var count: Int32 = 0
+    var unused: CTensorHandle?
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, &unused, &count, status)
+    checkOk(status)
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+  }
+
+%for n in range(1, 10 + 1):
+  @inlinable @inline(__always)
+  internal func execute<${", ".join(["T" + str(i) + " : TensorArrayProtocol" for i in range(n)])}>(
+    ${",\n    ".join(["_ count" + str(i) + ": Int" for i in range(n)])}
+  ) -> (${", ".join(["T" + str(i) for i in range(n)])}) {
+    var count = ${" + ".join(["Int32(count" + str(i) + ")" for i in range(n)])}
+    let buffer: UnsafeMutablePointer<CTensorHandle> =
+      UnsafeMutablePointer.allocate(capacity: Int(count))
+    _TFCOpSetDeviceFromScope(op, status)
+    checkOk(status)
+    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+    checkOk(status)
+%for i in range(n):
+    let offset${i} = ${"Int32(0)" if i == 0 else "offset" + str(i - 1) + " + Int32(count" + str(i - 1) + ")"}
+%end
+    let result = (
+      ${",\n      ".join(["T" + str(i) + ".init(_owning: buffer.advanced(by: Int(offset" + str(i) + ")), count: count" + str(i) + ")" for i in range(n)])})
+    buffer.deallocate()
+    TFE_DeleteOp(op)
+    TF_DeleteStatus(status)
+    return result
+  }
+
+%end
+}
diff --git a/Sources/TensorFlow/Bindings/README.md b/Sources/TensorFlow/Bindings/README.md
new file mode 100644
index 000000000..339780be1
--- /dev/null
+++ b/Sources/TensorFlow/Bindings/README.md
@@ -0,0 +1,32 @@
+**Note:** This folder is a temporary solution that should be
+restructured later to make the op bindings generation
+smoother. However, it is acceptable as a temporary solution 
+since it should not be necessary to run the op bindings
+generation script frequently.
+
+# Swift for TensorFlow Ops Bindings
+
+This folder contains the TensorFlow op bindings.
+
+These bindings are automatically generated from TensorFlow ops
+specified either using ops registered to the TensorFlow runtime
+or via a protobuf file similar to
+[ops.pbtxt](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/ops/ops.pbtxt)
+in the main TensorFlow repo.
+
+## How to regenerate the bindings
+
+To regenerate the swift ops bindings, run the following command. Note
+that this will use the TensorFlow (1.9 or above) python package.
+
+``` shell
+python generate_wrappers.py --output_path=RawOpsGenerated.swift
+```
+
+Documentation gets automatically generated when adding a path to the
+`api_def` proto directory. This directory should contain per operator
+`api_def` protos with names like `api_def_OpName.pbtxt`.
+
+```shell
+python generate_wrappers.py --output_path=RawOpsGenerated.swift --api_def_path=/path/to/tensorflow/core/api_def/base_api
+```
diff --git a/Sources/TensorFlow/Bindings/RawOpsGenerated.swift b/Sources/TensorFlow/Bindings/RawOpsGenerated.swift
new file mode 100644
index 000000000..36ddb6665
--- /dev/null
+++ b/Sources/TensorFlow/Bindings/RawOpsGenerated.swift
@@ -0,0 +1,35622 @@
+// !!! THIS CODE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND !!!
+//
+// Copyright 2018-19 Google LLC
+//
+// 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
+//
+//     https://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.
+
+import CTensorFlow
+
+
+public enum Raw {
+
+static let generatedTensorFlowVersion = "1.14.1-dev20190421"
+static let generatedTensorFlowGitVersion = "v1.12.1-149-gd57b65578c"
+
+// @_frozen // SR-9739
+public enum A {
+  case apples
+  case oranges
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .apples: return "apples"
+      case .oranges: return "oranges"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum DataFormat {
+  case nchw
+  case nhwc
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .nchw: return "NCHW"
+      case .nhwc: return "NHWC"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum DataFormat1 {
+  case ncdhw
+  case ndhwc
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .ncdhw: return "NCDHW"
+      case .ndhwc: return "NDHWC"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum DataFormat4 {
+  case nchw
+  case nchwVectC
+  case nhwc
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .nchw: return "NCHW"
+      case .nchwVectC: return "NCHW_VECT_C"
+      case .nhwc: return "NHWC"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum DensityUnit {
+  case cm
+  case in_
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .cm: return "cm"
+      case .in_: return "in"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum Direction {
+  case bidirectional
+  case unidirectional
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .bidirectional: return "bidirectional"
+      case .unidirectional: return "unidirectional"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum Errors {
+  case ignore
+  case replace
+  case strict
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .ignore: return "ignore"
+      case .replace: return "replace"
+      case .strict: return "strict"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum FinalOp {
+  case div
+  case id
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .div: return "Div"
+      case .id: return "Id"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum Format {
+  case empty
+  case grayscale
+  case rgb
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .empty: return ""
+      case .grayscale: return "grayscale"
+      case .rgb: return "rgb"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum InputMode {
+  case autoSelect
+  case linearInput
+  case skipInput
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .autoSelect: return "auto_select"
+      case .linearInput: return "linear_input"
+      case .skipInput: return "skip_input"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum LossType {
+  case hingeLoss
+  case logisticLoss
+  case poissonLoss
+  case smoothHingeLoss
+  case squaredLoss
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .hingeLoss: return "hinge_loss"
+      case .logisticLoss: return "logistic_loss"
+      case .poissonLoss: return "poisson_loss"
+      case .smoothHingeLoss: return "smooth_hinge_loss"
+      case .squaredLoss: return "squared_loss"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum MergeOp {
+  case add
+  case max
+  case min
+  case mul
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .add: return "Add"
+      case .max: return "Max"
+      case .min: return "Min"
+      case .mul: return "Mul"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum Method {
+  case bilinear
+  case nearest
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .bilinear: return "bilinear"
+      case .nearest: return "nearest"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum Method3 {
+  case bilinear
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .bilinear: return "bilinear"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum Mode {
+  case minCombined
+  case minFirst
+  case scaled
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .minCombined: return "MIN_COMBINED"
+      case .minFirst: return "MIN_FIRST"
+      case .scaled: return "SCALED"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum Mode5 {
+  case reflect
+  case symmetric
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .reflect: return "REFLECT"
+      case .symmetric: return "SYMMETRIC"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum OutputEncoding {
+  case utf16Be
+  case utf32Be
+  case utf8
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .utf16Be: return "UTF-16-BE"
+      case .utf32Be: return "UTF-32-BE"
+      case .utf8: return "UTF-8"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum Padding {
+  case same
+  case valid
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .same: return "SAME"
+      case .valid: return "VALID"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum Padding2 {
+  case explicit
+  case same
+  case valid
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .explicit: return "EXPLICIT"
+      case .same: return "SAME"
+      case .valid: return "VALID"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum Reduction {
+  case max
+  case min
+  case prod
+  case sum
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .max: return "max"
+      case .min: return "min"
+      case .prod: return "prod"
+      case .sum: return "sum"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum RnnMode {
+  case gru
+  case lstm
+  case rnnRelu
+  case rnnTanh
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .gru: return "gru"
+      case .lstm: return "lstm"
+      case .rnnRelu: return "rnn_relu"
+      case .rnnTanh: return "rnn_tanh"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum RoundMode {
+  case halfToEven
+  case halfUp
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .halfToEven: return "HALF_TO_EVEN"
+      case .halfUp: return "HALF_UP"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum RoundMode6 {
+  case halfAwayFromZero
+  case halfToEven
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .halfAwayFromZero: return "HALF_AWAY_FROM_ZERO"
+      case .halfToEven: return "HALF_TO_EVEN"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum SplitType {
+  case inequality
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .inequality: return "inequality"
+      }
+    }
+  }
+}
+
+// @_frozen // SR-9739
+public enum Unit {
+  case byte
+  case utf8Char
+
+  @inlinable
+  var cName: String {
+    @inline(__always)
+    get {
+      switch self {
+      case .byte: return "BYTE"
+      case .utf8Char: return "UTF8_CHAR"
+      }
+    }
+  }
+}
+
+
+@inlinable @inline(__always)
+public static func a(
+) -> Tensor<Float> {
+  let op = TFE_Op("A")
+  
+  return op.execute(Int(1))
+}
+
+/// Raise a exception to abort the process when called.
+///
+/// If exit_without_error is true, the process will exit normally,
+/// otherwise it will exit with a SIGABORT signal.
+///
+/// Returns nothing but an exception.
+///
+/// - Attr error_msg: A string which is the message associated with the exception.
+@inlinable @inline(__always)
+public static func abort(
+  errorMsg: String,
+  exitWithoutError: Bool = false
+) {
+  let op = TFE_Op("Abort")
+  op.setAttr("error_msg", errorMsg)
+  op.setAttr("exit_without_error", exitWithoutError)
+  op.execute()
+}
+
+/// Computes the absolute value of a tensor.
+///
+/// Given a tensor `x`, this operation returns a tensor containing the absolute
+/// value of each element in `x`. For example, if x is an input element and y is
+/// an output element, this operation computes \\(y = |x|\\).
+@inlinable @inline(__always)
+public static func abs<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Abs")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns the element-wise sum of a list of tensors.
+///
+/// `tf.accumulate_n_v2` performs the same operation as `tf.add_n`, but does not
+/// wait for all of its inputs to be ready before beginning to sum. This can
+/// save memory if inputs are ready at different times, since minimum temporary
+/// storage is proportional to the output size rather than the inputs size.
+///
+/// Unlike the original `accumulate_n`, `accumulate_n_v2` is differentiable.
+///
+/// Returns a `Tensor` of same shape and type as the elements of `inputs`.
+///
+/// - Parameter inputs: A list of `Tensor` objects, each with same shape and type.
+///
+/// - Attr shape: Shape of elements of `inputs`.
+@inlinable @inline(__always)
+public static func accumulateNV2<T: Numeric & TensorFlowScalar>(
+  inputs: [Tensor<T>],
+  shape: TensorShape?
+) -> Tensor<T> {
+  let op = TFE_Op("AccumulateNV2")
+  op.setAttr("N", inputs.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("shape", shape)
+  let _ = op.addInputList(inputs)
+  return op.execute(Int(1))
+}
+
+/// Computes acos of x element-wise.
+@inlinable @inline(__always)
+public static func acos<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Acos")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes inverse hyperbolic cosine of x element-wise.
+@inlinable @inline(__always)
+public static func acosh<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Acosh")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns x + y element-wise.
+///
+/// *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func add<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Add")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns x + y element-wise.
+///
+/// *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func add(
+  _ x: StringTensor,
+  _ y: StringTensor
+) -> StringTensor {
+  let op = TFE_Op("Add")
+  op.setAttr("T", TensorDataType(TF_STRING))
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Add an `N`-minibatch `SparseTensor` to a `SparseTensorsMap`, return `N` handles.
+///
+/// A `SparseTensor` of rank `R` is represented by three tensors: `sparse_indices`,
+/// `sparse_values`, and `sparse_shape`, where
+///
+/// ```sparse_indices.shape[1] == sparse_shape.shape[0] == R```
+///
+/// An `N`-minibatch of `SparseTensor` objects is represented as a `SparseTensor`
+/// having a first `sparse_indices` column taking values between `[0, N)`, where
+/// the minibatch size `N == sparse_shape[0]`.
+///
+/// The input `SparseTensor` must have rank `R` greater than 1, and the first
+/// dimension is treated as the minibatch dimension.  Elements of the `SparseTensor`
+/// must be sorted in increasing order of this first dimension.  The stored
+/// `SparseTensor` objects pointed to by each row of the output `sparse_handles`
+/// will have rank `R-1`.
+///
+/// The `SparseTensor` values can then be read out as part of a minibatch by passing
+/// the given keys as vector elements to `TakeManySparseFromTensorsMap`.  To ensure
+/// the correct `SparseTensorsMap` is accessed, ensure that the same
+/// `container` and `shared_name` are passed to that Op.  If no `shared_name`
+/// is provided here, instead use the *name* of the Operation created by calling
+/// `AddManySparseToTensorsMap` as the `shared_name` passed to
+/// `TakeManySparseFromTensorsMap`.  Ensure the Operations are colocated.
+///
+/// - Parameters:
+///   - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
+///     `sparse_indices[:, 0]` must be ordered values in `[0, N)`.
+///   - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
+///   - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
+///     The minibatch size `N == sparse_shape[0]`.
+///
+/// - Attrs:
+///   - container: The container name for the `SparseTensorsMap` created by this op.
+///   - shared_name: The shared name for the `SparseTensorsMap` created by this op.
+///     If blank, the new Operation's unique name is used.
+///
+/// - Output sparse_handles: 1-D.  The handles of the `SparseTensor` now stored in the
+///   `SparseTensorsMap`.  Shape: `[N]`.
+@inlinable @inline(__always)
+public static func addManySparseToTensorsMap<T: TensorFlowScalar>(
+  sparseIndices: Tensor<Int64>,
+  sparseValues: Tensor<T>,
+  sparseShape: Tensor<Int64>,
+  container: String,
+  sharedName: String
+) -> Tensor<Int64> {
+  let op = TFE_Op("AddManySparseToTensorsMap")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(sparseIndices)
+  let _ = op.addInput(sparseValues)
+  let _ = op.addInput(sparseShape)
+  return op.execute(Int(1))
+}
+
+/// Add all input tensors element wise.
+///
+/// - Parameter inputs: Must all be the same size and shape.
+@inlinable @inline(__always)
+public static func addN<T: Numeric & TensorFlowScalar>(
+  inputs: [Tensor<T>]
+) -> Tensor<T> {
+  let op = TFE_Op("AddN")
+  op.setAttr("N", inputs.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInputList(inputs)
+  return op.execute(Int(1))
+}
+
+/// Add a `SparseTensor` to a `SparseTensorsMap` return its handle.
+///
+/// A `SparseTensor` is represented by three tensors: `sparse_indices`,
+/// `sparse_values`, and `sparse_shape`.
+///
+/// This operator takes the given `SparseTensor` and adds it to a container
+/// object (a `SparseTensorsMap`).  A unique key within this container is generated
+/// in the form of an `int64`, and this is the value that is returned.
+///
+/// The `SparseTensor` can then be read out as part of a minibatch by passing
+/// the key as a vector element to `TakeManySparseFromTensorsMap`.  To ensure
+/// the correct `SparseTensorsMap` is accessed, ensure that the same
+/// `container` and `shared_name` are passed to that Op.  If no `shared_name`
+/// is provided here, instead use the *name* of the Operation created by calling
+/// `AddSparseToTensorsMap` as the `shared_name` passed to
+/// `TakeManySparseFromTensorsMap`.  Ensure the Operations are colocated.
+///
+/// - Parameters:
+///   - sparse_indices: 2-D.  The `indices` of the `SparseTensor`.
+///   - sparse_values: 1-D.  The `values` of the `SparseTensor`.
+///   - sparse_shape: 1-D.  The `shape` of the `SparseTensor`.
+///
+/// - Attrs:
+///   - container: The container name for the `SparseTensorsMap` created by this op.
+///   - shared_name: The shared name for the `SparseTensorsMap` created by this op.
+///     If blank, the new Operation's unique name is used.
+///
+/// - Output sparse_handle: 0-D.  The handle of the `SparseTensor` now stored in the
+///   `SparseTensorsMap`.
+@inlinable @inline(__always)
+public static func addSparseToTensorsMap<T: TensorFlowScalar>(
+  sparseIndices: Tensor<Int64>,
+  sparseValues: Tensor<T>,
+  sparseShape: Tensor<Int64>,
+  container: String,
+  sharedName: String
+) -> Tensor<Int64> {
+  let op = TFE_Op("AddSparseToTensorsMap")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(sparseIndices)
+  let _ = op.addInput(sparseValues)
+  let _ = op.addInput(sparseShape)
+  return op.execute(Int(1))
+}
+
+/// Returns x + y element-wise.
+///
+/// *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func addV2<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("AddV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Deprecated. Disallowed in GraphDef version >= 2.
+@inlinable @inline(__always)
+public static func adjustContrast<T: Numeric & TensorFlowScalar>(
+  images: Tensor<T>,
+  contrastFactor: Tensor<Float>,
+  minValue: Tensor<Float>,
+  maxValue: Tensor<Float>
+) -> Tensor<Float> {
+  let op = TFE_Op("AdjustContrast")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(images)
+  let _ = op.addInput(contrastFactor)
+  let _ = op.addInput(minValue)
+  let _ = op.addInput(maxValue)
+  return op.execute(Int(1))
+}
+
+/// Adjust the contrast of one or more images.
+///
+/// `images` is a tensor of at least 3 dimensions.  The last 3 dimensions are
+/// interpreted as `[height, width, channels]`.  The other dimensions only
+/// represent a collection of images, such as `[batch, height, width, channels].`
+///
+/// Contrast is adjusted independently for each channel of each image.
+///
+/// For each channel, the Op first computes the mean of the image pixels in the
+/// channel and then adjusts each component of each pixel to
+/// `(x - mean) * contrast_factor + mean`.
+///
+/// - Parameters:
+///   - images: Images to adjust.  At least 3-D.
+///   - contrast_factor: A float multiplier for adjusting contrast.
+///
+/// - Output output: The contrast-adjusted image or images.
+@inlinable @inline(__always)
+public static func adjustContrastv2<T: FloatingPoint & TensorFlowScalar>(
+  images: Tensor<T>,
+  contrastFactor: Tensor<Float>
+) -> Tensor<T> {
+  let op = TFE_Op("AdjustContrastv2")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(images)
+  let _ = op.addInput(contrastFactor)
+  return op.execute(Int(1))
+}
+
+/// Adjust the hue of one or more images.
+///
+/// `images` is a tensor of at least 3 dimensions.  The last dimension is
+/// interpretted as channels, and must be three.
+///
+/// The input image is considered in the RGB colorspace. Conceptually, the RGB
+/// colors are first mapped into HSV. A delta is then applied all the hue values,
+/// and then remapped back to RGB colorspace.
+///
+/// - Parameters:
+///   - images: Images to adjust.  At least 3-D.
+///   - delta: A float delta to add to the hue.
+///
+/// - Output output: The hue-adjusted image or images.
+@inlinable @inline(__always)
+public static func adjustHue<T: FloatingPoint & TensorFlowScalar>(
+  images: Tensor<T>,
+  delta: Tensor<Float>
+) -> Tensor<T> {
+  let op = TFE_Op("AdjustHue")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(images)
+  let _ = op.addInput(delta)
+  return op.execute(Int(1))
+}
+
+/// Adjust the saturation of one or more images.
+///
+/// `images` is a tensor of at least 3 dimensions.  The last dimension is
+/// interpretted as channels, and must be three.
+///
+/// The input image is considered in the RGB colorspace. Conceptually, the RGB
+/// colors are first mapped into HSV. A scale is then applied all the saturation
+/// values, and then remapped back to RGB colorspace.
+///
+/// - Parameters:
+///   - images: Images to adjust.  At least 3-D.
+///   - scale: A float scale to add to the saturation.
+///
+/// - Output output: The hue-adjusted image or images.
+@inlinable @inline(__always)
+public static func adjustSaturation<T: FloatingPoint & TensorFlowScalar>(
+  images: Tensor<T>,
+  scale: Tensor<Float>
+) -> Tensor<T> {
+  let op = TFE_Op("AdjustSaturation")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(images)
+  let _ = op.addInput(scale)
+  return op.execute(Int(1))
+}
+
+/// Computes the "logical and" of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///   - input: The tensor to reduce.
+///   - reduction_indices: The dimensions to reduce. Must be in the range
+///     `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func all<Tidx: BinaryInteger & TensorFlowScalar>(
+  _ input: Tensor<Bool>,
+  reductionIndices: Tensor<Tidx>,
+  keepDims: Bool = false
+) -> Tensor<Bool> {
+  let op = TFE_Op("All")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(reductionIndices)
+  return op.execute(Int(1))
+}
+
+/// Generates labels for candidate sampling with a learned unigram distribution.
+///
+/// See explanations of candidate sampling and the data formats at
+/// go/candidate-sampling.
+///
+/// For each batch, this op picks a single set of sampled candidate labels.
+///
+/// The advantages of sampling candidates per-batch are simplicity and the
+/// possibility of efficient dense matrix multiplication. The disadvantage is that
+/// the sampled candidates must be chosen independently of the context and of the
+/// true labels.
+///
+/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
+///   IDs of the num_true target_classes in the corresponding original label.
+///
+/// - Attrs:
+///   - num_true: Number of true labels per context.
+///   - num_sampled: Number of candidates to produce.
+///   - unique: If unique is true, we sample with rejection, so that all sampled
+///     candidates in a batch are unique. This requires some approximation to
+///     estimate the post-rejection sampling probabilities.
+///   - seed: If either seed or seed2 are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///   - sampled_candidates: A vector of length num_sampled, in which each element is
+///     the ID of a sampled candidate.
+///   - true_expected_count: A batch_size * num_true matrix, representing
+///     the number of times each candidate is expected to occur in a batch
+///     of sampled candidates. If unique=true, then this is a probability.
+///   - sampled_expected_count: A vector of length num_sampled, for each sampled
+///     candidate representing the number of times the candidate is expected
+///     to occur in a batch of sampled candidates.  If unique=true, then this is a
+///     probability.
+@inlinable @inline(__always)
+public static func allCandidateSampler(
+  trueClasses: Tensor<Int64>,
+  numTrue: Int64,
+  numSampled: Int64,
+  unique: Bool,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
+  let op = TFE_Op("AllCandidateSampler")
+  op.setAttr("num_true", numTrue)
+  op.setAttr("num_sampled", numSampled)
+  op.setAttr("unique", unique)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(trueClasses)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// An Op to exchange data across TPU replicas.
+///
+/// On each replica, the input is split into `split_count` blocks along
+/// `split_dimension` and send to the other replicas given group_assignment. After
+/// receiving `split_count` - 1 blocks from other replicas, we concatenate the
+/// blocks along `concat_dimension` as the output.
+///
+/// For example, suppose there are 2 TPU replicas:
+/// replica 0 receives input: `[[A, B]]`
+/// replica 1 receives input: `[[C, D]]`
+///
+/// group_assignment=`[[0, 1]]`
+/// concat_dimension=0
+/// split_dimension=1
+/// split_count=2
+///
+/// replica 0's output: `[[A], [C]]`
+/// replica 1's output: `[[B], [D]]`
+///
+/// - Parameters:
+///   - input: The local input to the sum.
+///   - group_assignment: An int32 tensor with shape
+///     [num_groups, num_replicas_per_group]. `group_assignment[i]` represents the
+///     replica ids in the ith subgroup.
+///
+/// - Attrs:
+///   - T: The type of elements to be exchanged.
+///   - concat_dimension: The dimension number to concatenate.
+///   - split_dimension: The dimension number to split.
+///   - split_count: The number of splits, this number must equal to the sub-group
+///     size(group_assignment.get_shape()[1])
+///
+/// - Output output: The exchanged result.
+@inlinable @inline(__always)
+public static func allToAll<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  groupAssignment: Tensor<Int32>,
+  concatDimension: Int64,
+  splitDimension: Int64,
+  splitCount: Int64
+) -> Tensor<T> {
+  let op = TFE_Op("AllToAll")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("concat_dimension", concatDimension)
+  op.setAttr("split_dimension", splitDimension)
+  op.setAttr("split_count", splitCount)
+  let _ = op.addInput(input)
+  let _ = op.addInput(groupAssignment)
+  return op.execute(Int(1))
+}
+
+/// Returns the argument of a complex number.
+///
+/// Given a tensor `input` of complex numbers, this operation returns a tensor of
+/// type `float` that is the argument of each element in `input`. All elements in
+/// `input` must be complex numbers of the form \\(a + bj\\), where *a*
+/// is the real part and *b* is the imaginary part.
+///
+/// The argument returned by this operation is of the form \\(atan2(b, a)\\).
+///
+/// For example:
+///
+/// ```
+/// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
+/// tf.angle(input) ==> [2.0132, 1.056]
+/// ```
+///
+/// @compatibility(numpy)
+/// Equivalent to np.angle.
+/// @end_compatibility
+@inlinable @inline(__always)
+public static func angle<
+    T: TensorFlowScalar,
+    Tout: FloatingPoint & TensorFlowScalar
+>(
+  _ input: Tensor<T>
+) -> Tensor<Tout> {
+  let op = TFE_Op("Angle")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tout", Tout.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// A container for an iterator resource.
+///
+/// - Output handle: A handle to the iterator that can be passed to a "MakeIterator" or
+///   "IteratorGetNext" op. In contrast to Iterator, AnonymousIterator prevents
+///   resource sharing by name, and does not keep a reference to the resource
+///   container.
+@inlinable @inline(__always)
+public static func anonymousIterator(
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let op = TFE_Op("AnonymousIterator")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  return op.execute(Int(1))
+}
+
+/// A container for an iterator resource.
+///
+/// - Outputs:
+///   - handle: A handle to the iterator that can be passed to a "MakeIterator" or
+///     "IteratorGetNext" op. In contrast to Iterator, AnonymousIterator prevents
+///     resource sharing by name, and does not keep a reference to the resource
+///     container.
+///   - deleter: A variant deleter that should be passed into the op that deletes the iterator.
+@inlinable @inline(__always)
+public static func anonymousIteratorV2(
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> (handle: ResourceHandle, deleter: VariantHandle) {
+  let op = TFE_Op("AnonymousIteratorV2")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Computes the "logical or" of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///   - input: The tensor to reduce.
+///   - reduction_indices: The dimensions to reduce. Must be in the range
+///     `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func any<Tidx: BinaryInteger & TensorFlowScalar>(
+  _ input: Tensor<Bool>,
+  reductionIndices: Tensor<Tidx>,
+  keepDims: Bool = false
+) -> Tensor<Bool> {
+  let op = TFE_Op("Any")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(reductionIndices)
+  return op.execute(Int(1))
+}
+
+/// Returns the truth value of abs(x-y) < tolerance element-wise.
+@inlinable @inline(__always)
+public static func approximateEqual<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>,
+  tolerance: Double = 1e-05
+) -> Tensor<Bool> {
+  let op = TFE_Op("ApproximateEqual")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("tolerance", tolerance)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns the index with the largest value across dimensions of a tensor.
+///
+/// Note that in case of ties the identity of the return value is not guaranteed.
+///
+/// Usage:
+///   ```python
+///   import tensorflow as tf
+///   a = [1, 10, 26.9, 2.8, 166.32, 62.3]
+///   b = tf.math.argmax(input = a)
+///   c = tf.keras.backend.eval(b)  
+///   # c = 4
+///   # here a[4] = 166.32 which is the largest element of a across axis 0
+///   ```
+///
+/// - Parameter dimension: int32 or int64, must be in the range `[-rank(input), rank(input))`.
+///   Describes which dimension of the input Tensor to reduce across. For vectors,
+///   use dimension = 0.
+@inlinable @inline(__always)
+public static func argMax<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar,
+    OutputType: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  dimension: Tensor<Tidx>
+) -> Tensor<OutputType> {
+  let op = TFE_Op("ArgMax")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  op.setAttr("output_type", OutputType.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(dimension)
+  return op.execute(Int(1))
+}
+
+/// Returns the index with the smallest value across dimensions of a tensor.
+///
+/// Note that in case of ties the identity of the return value is not guaranteed.
+///
+/// Usage:
+///   ```python
+///   import tensorflow as tf
+///   a = [1, 10, 26.9, 2.8, 166.32, 62.3]
+///   b = tf.math.argmin(input = a)
+///   c = tf.keras.backend.eval(b)  
+///   # c = 0
+///   # here a[0] = 1 which is the smallest element of a across axis 0
+///   ```
+///
+/// - Parameter dimension: int32 or int64, must be in the range `[-rank(input), rank(input))`.
+///   Describes which dimension of the input Tensor to reduce across. For vectors,
+///   use dimension = 0.
+@inlinable @inline(__always)
+public static func argMin<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar,
+    OutputType: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  dimension: Tensor<Tidx>
+) -> Tensor<OutputType> {
+  let op = TFE_Op("ArgMin")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  op.setAttr("output_type", OutputType.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(dimension)
+  return op.execute(Int(1))
+}
+
+/// Converts each entry in the given tensor to strings.  Supports many numeric
+///
+/// types and boolean.
+///
+/// - Attrs:
+///   - precision: The post-decimal precision to use for floating point numbers.
+///     Only used if precision > -1.
+///   - scientific: Use scientific notation for floating point numbers.
+///   - shortest: Use shortest representation (either scientific or standard) for
+///     floating point numbers.
+///   - width: Pad pre-decimal numbers to this width.
+///     Applies to both floating point and integer numbers.
+///     Only used if width > -1.
+///   - fill: The value to pad if width > -1.  If empty, pads with spaces.
+///     Another typical value is '0'.  String cannot be longer than 1 character.
+@inlinable @inline(__always)
+public static func asString<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  precision: Int64 = -1,
+  scientific: Bool = false,
+  shortest: Bool = false,
+  width: Int64 = -1,
+  fill: String
+) -> StringTensor {
+  let op = TFE_Op("AsString")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("precision", precision)
+  op.setAttr("scientific", scientific)
+  op.setAttr("shortest", shortest)
+  op.setAttr("width", width)
+  op.setAttr("fill", fill)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Computes the trignometric inverse sine of x element-wise.
+///
+/// The `tf.math.asin` operation returns the inverse of `tf.math.sin`, such that
+/// if `y = tf.math.sin(x)` then, `x = tf.math.asin(y)`.
+///
+/// **Note**: The output of `tf.math.asin` will lie within the invertible range 
+/// of sine, i.e [-pi/2, pi/2].
+///
+/// For example:
+///
+/// ```python
+/// # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)]
+/// x = tf.constant([1.047, 0.785])
+/// y = tf.math.sin(x) # [0.8659266, 0.7068252]
+///
+/// tf.math.asin(y) # [1.047, 0.785] = x
+/// ```
+///
+@inlinable @inline(__always)
+public static func asin<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Asin")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes inverse hyperbolic sine of x element-wise.
+@inlinable @inline(__always)
+public static func asinh<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Asinh")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Asserts that the given condition is true.
+///
+/// If `condition` evaluates to false, print the list of tensors in `data`.
+/// `summarize` determines how many entries of the tensors to print.
+///
+/// - Parameters:
+///   - condition: The condition to evaluate.
+///   - data: The tensors to print out when condition is false.
+///
+/// - Attr summarize: Print this many entries of each tensor.
+@inlinable @inline(__always)
+public static func assert<T: TensorArrayProtocol>(
+  condition: Tensor<Bool>,
+  data: T,
+  summarize: Int64 = 3
+) {
+  let op = TFE_Op("Assert")
+  op.setAttr("T", data._typeList)
+  op.setAttr("summarize", summarize)
+  let _ = op.addInput(condition)
+  let _ = op.addInputList(data)
+  op.execute()
+}
+
+/// Adds a value to the current value of a variable.
+///
+/// Any ReadVariableOp with a control dependency on this op is guaranteed to
+/// see the incremented value or a subsequent newer one.
+///
+/// - Parameters:
+///   - resource: handle to the resource in which to store the variable.
+///   - value: the value by which the variable will be incremented.
+///
+/// - Attr dtype: the dtype of the value.
+@inlinable @inline(__always)
+public static func assignAddVariableOp<Dtype: TensorFlowScalar>(
+  resource: ResourceHandle,
+  value: Tensor<Dtype>
+) {
+  let op = TFE_Op("AssignAddVariableOp")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(value)
+  op.execute()
+}
+
+/// Subtracts a value from the current value of a variable.
+///
+/// Any ReadVariableOp with a control dependency on this op is guaranteed to
+/// see the decremented value or a subsequent newer one.
+///
+/// - Parameters:
+///   - resource: handle to the resource in which to store the variable.
+///   - value: the value by which the variable will be incremented.
+///
+/// - Attr dtype: the dtype of the value.
+@inlinable @inline(__always)
+public static func assignSubVariableOp<Dtype: TensorFlowScalar>(
+  resource: ResourceHandle,
+  value: Tensor<Dtype>
+) {
+  let op = TFE_Op("AssignSubVariableOp")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(value)
+  op.execute()
+}
+
+/// Assigns a new value to a variable.
+///
+/// Any ReadVariableOp with a control dependency on this op is guaranteed to return
+/// this value or a subsequent newer value of the variable.
+///
+/// - Parameters:
+///   - resource: handle to the resource in which to store the variable.
+///   - value: the value to set the new tensor to use.
+///
+/// - Attr dtype: the dtype of the value.
+@inlinable @inline(__always)
+public static func assignVariableOp<Dtype: TensorFlowScalar>(
+  resource: ResourceHandle,
+  value: Tensor<Dtype>
+) {
+  let op = TFE_Op("AssignVariableOp")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(value)
+  op.execute()
+}
+
+/// Computes the trignometric inverse tangent of x element-wise.
+///
+/// The `tf.math.atan` operation returns the inverse of `tf.math.tan`, such that
+/// if `y = tf.math.tan(x)` then, `x = tf.math.atan(y)`.
+///
+/// **Note**: The output of `tf.math.atan` will lie within the invertible range 
+/// of tan, i.e (-pi/2, pi/2).
+///
+/// For example:
+///
+/// ```python
+/// # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)]
+/// x = tf.constant([1.047, 0.785])
+/// y = tf.math.tan(x) # [1.731261, 0.99920404]
+///
+/// tf.math.atan(y) # [1.047, 0.785] = x
+/// ```
+///
+@inlinable @inline(__always)
+public static func atan<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Atan")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes arctangent of `y/x` element-wise, respecting signs of the arguments.
+///
+/// This is the angle \( \theta \in [-\pi, \pi] \) such that
+/// \[ x = r \cos(\theta) \]
+/// and
+/// \[ y = r \sin(\theta) \]
+/// where \(r = \sqrt(x^2 + y^2) \).
+@inlinable @inline(__always)
+public static func atan2<T: FloatingPoint & TensorFlowScalar>(
+  _ y: Tensor<T>,
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Atan2")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(y)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes inverse hyperbolic tangent of x element-wise.
+@inlinable @inline(__always)
+public static func atanh<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Atanh")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func attr(
+  _ a: Int64
+) {
+  let op = TFE_Op("Attr")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrBool(
+  _ a: Bool
+) {
+  let op = TFE_Op("AttrBool")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrBoolList(
+  _ a: [Bool]
+) {
+  let op = TFE_Op("AttrBoolList")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrDefault(
+  _ a: String = "banana"
+) {
+  let op = TFE_Op("AttrDefault")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrEmptyListDefault(
+  _ a: [Double]
+) {
+  let op = TFE_Op("AttrEmptyListDefault")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrEnum(
+  _ a: A
+) {
+  let op = TFE_Op("AttrEnum")
+  op.setAttr("a", a.cName)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrEnumList(
+  _ a: [String]
+) {
+  let op = TFE_Op("AttrEnumList")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrFloat(
+  _ a: Double
+) {
+  let op = TFE_Op("AttrFloat")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrListDefault(
+  _ a: [Int32] = [5, 15]
+) {
+  let op = TFE_Op("AttrListDefault")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrListMin(
+  _ a: [Int32]
+) {
+  let op = TFE_Op("AttrListMin")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrListTypeDefault<T: TensorFlowScalar>(
+  _ a: [Tensor<T>],
+  _ b: [Tensor<T>]
+) {
+  let op = TFE_Op("AttrListTypeDefault")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("N", a.count)
+  let _ = op.addInputList(a)
+  let _ = op.addInputList(b)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrMin(
+  _ a: Int64
+) {
+  let op = TFE_Op("AttrMin")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrPartialShape(
+  _ a: TensorShape?
+) {
+  let op = TFE_Op("AttrPartialShape")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrPartialShapeList(
+  _ a: [TensorShape?]
+) {
+  let op = TFE_Op("AttrPartialShapeList")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrShape(
+  _ a: TensorShape?
+) {
+  let op = TFE_Op("AttrShape")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrShapeList(
+  _ a: [TensorShape?]
+) {
+  let op = TFE_Op("AttrShapeList")
+  op.setAttr("a", a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrTypeDefault<T: TensorFlowScalar>(
+  _ a: Tensor<T>
+) {
+  let op = TFE_Op("AttrTypeDefault")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  op.execute()
+}
+
+/// Produces a visualization of audio data over time.
+///
+/// Spectrograms are a standard way of representing audio information as a series of
+/// slices of frequency information, one slice for each window of time. By joining
+/// these together into a sequence, they form a distinctive fingerprint of the sound
+/// over time.
+///
+/// This op expects to receive audio data as an input, stored as floats in the range
+/// -1 to 1, together with a window width in samples, and a stride specifying how
+/// far to move the window between slices. From this it generates a three
+/// dimensional output. The lowest dimension has an amplitude value for each
+/// frequency during that time slice. The next dimension is time, with successive
+/// frequency slices. The final dimension is for the channels in the input, so a
+/// stereo audio input would have two here for example.
+///
+/// This means the layout when converted and saved as an image is rotated 90 degrees
+/// clockwise from a typical spectrogram. Time is descending down the Y axis, and
+/// the frequency decreases from left to right.
+///
+/// Each value in the result represents the square root of the sum of the real and
+/// imaginary parts of an FFT on the current window of samples. In this way, the
+/// lowest dimension represents the power of each frequency in the current window,
+/// and adjacent windows are concatenated in the next dimension.
+///
+/// To get a more intuitive and visual look at what this operation does, you can run
+/// tensorflow/examples/wav_to_spectrogram to read in an audio file and save out the
+/// resulting spectrogram as a PNG image.
+///
+/// - Parameter input: Float representation of audio data.
+///
+/// - Attrs:
+///   - window_size: How wide the input window is in samples. For the highest efficiency
+///     this should be a power of two, but other values are accepted.
+///   - stride: How widely apart the center of adjacent sample windows should be.
+///   - magnitude_squared: Whether to return the squared magnitude or just the
+///     magnitude. Using squared magnitude can avoid extra calculations.
+///
+/// - Output spectrogram: 3D representation of the audio frequencies as an image.
+@inlinable @inline(__always)
+public static func audioSpectrogram(
+  _ input: Tensor<Float>,
+  windowSize: Int64,
+  stride: Int64,
+  magnitudeSquared: Bool = false
+) -> Tensor<Float> {
+  let op = TFE_Op("AudioSpectrogram")
+  op.setAttr("window_size", windowSize)
+  op.setAttr("stride", stride)
+  op.setAttr("magnitude_squared", magnitudeSquared)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Outputs a `Summary` protocol buffer with audio.
+///
+/// The summary has up to `max_outputs` summary values containing audio. The
+/// audio is built from `tensor` which must be 3-D with shape `[batch_size,
+/// frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are
+/// assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`.
+///
+/// The `tag` argument is a scalar `Tensor` of type `string`.  It is used to
+/// build the `tag` of the summary values:
+///
+/// *  If `max_outputs` is 1, the summary value tag is '*tag*/audio'.
+/// *  If `max_outputs` is greater than 1, the summary value tags are
+///    generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc.
+///
+/// - Parameters:
+///   - tag: Scalar. Used to build the `tag` attribute of the summary values.
+///   - tensor: 2-D of shape `[batch_size, frames]`.
+///
+/// - Attrs:
+///   - sample_rate: The sample rate of the signal in hertz.
+///   - max_outputs: Max number of batch elements to generate audio for.
+///
+/// - Output summary: Scalar. Serialized `Summary` protocol buffer.
+@inlinable @inline(__always)
+public static func audioSummary(
+  tag: StringTensor,
+  _ tensor: Tensor<Float>,
+  sampleRate: Double,
+  maxOutputs: Int64 = 3
+) -> StringTensor {
+  let op = TFE_Op("AudioSummary")
+  op.setAttr("sample_rate", sampleRate)
+  op.setAttr("max_outputs", maxOutputs)
+  let _ = op.addInput(tag)
+  let _ = op.addInput(tensor)
+  return op.execute(Int(1))
+}
+
+/// Outputs a `Summary` protocol buffer with audio.
+///
+/// The summary has up to `max_outputs` summary values containing audio. The
+/// audio is built from `tensor` which must be 3-D with shape `[batch_size,
+/// frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are
+/// assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`.
+///
+/// The `tag` argument is a scalar `Tensor` of type `string`.  It is used to
+/// build the `tag` of the summary values:
+///
+/// *  If `max_outputs` is 1, the summary value tag is '*tag*/audio'.
+/// *  If `max_outputs` is greater than 1, the summary value tags are
+///    generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc.
+///
+/// - Parameters:
+///   - tag: Scalar. Used to build the `tag` attribute of the summary values.
+///   - tensor: 2-D of shape `[batch_size, frames]`.
+///   - sample_rate: The sample rate of the signal in hertz.
+///
+/// - Attr max_outputs: Max number of batch elements to generate audio for.
+///
+/// - Output summary: Scalar. Serialized `Summary` protocol buffer.
+@inlinable @inline(__always)
+public static func audioSummaryV2(
+  tag: StringTensor,
+  _ tensor: Tensor<Float>,
+  sampleRate: Tensor<Float>,
+  maxOutputs: Int64 = 3
+) -> StringTensor {
+  let op = TFE_Op("AudioSummaryV2")
+  op.setAttr("max_outputs", maxOutputs)
+  let _ = op.addInput(tag)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(sampleRate)
+  return op.execute(Int(1))
+}
+
+/// Performs average pooling on the input.
+///
+/// Each entry in `output` is the mean of the corresponding size `ksize`
+/// window in `value`.
+///
+/// - Parameter value: 4-D with shape `[batch, height, width, channels]`.
+///
+/// - Attrs:
+///   - ksize: The size of the sliding window for each dimension of `value`.
+///   - strides: The stride of the sliding window for each dimension of `value`.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, in_channels, in_height, in_width].
+///
+/// - Output output: The average pooled output tensor.
+@inlinable @inline(__always)
+public static func avgPool<T: FloatingPoint & TensorFlowScalar>(
+  value: Tensor<T>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let op = TFE_Op("AvgPool")
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(value)
+  return op.execute(Int(1))
+}
+
+/// Performs 3D average pooling on the input.
+///
+/// - Parameter input: Shape `[batch, depth, rows, cols, channels]` tensor to pool over.
+///
+/// - Attrs:
+///   - ksize: 1-D tensor of length 5. The size of the window for each dimension of
+///     the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: The data format of the input and output data. With the
+///     default format "NDHWC", the data is stored in the order of:
+///         [batch, in_depth, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCDHW", the data storage order is:
+///         [batch, in_channels, in_depth, in_height, in_width].
+///
+/// - Output output: The average pooled output tensor.
+@inlinable @inline(__always)
+public static func avgPool3D<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat1 = .ndhwc
+) -> Tensor<T> {
+  let op = TFE_Op("AvgPool3D")
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Computes gradients of average pooling function.
+///
+/// - Parameters:
+///   - orig_input_shape: The original input dimensions.
+///   - grad: Output backprop of shape `[batch, depth, rows, cols, channels]`.
+///
+/// - Attrs:
+///   - ksize: 1-D tensor of length 5. The size of the window for each dimension of
+///     the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: The data format of the input and output data. With the
+///     default format "NDHWC", the data is stored in the order of:
+///         [batch, in_depth, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCDHW", the data storage order is:
+///         [batch, in_channels, in_depth, in_height, in_width].
+///
+/// - Output output: The backprop for input.
+@inlinable @inline(__always)
+public static func avgPool3DGrad<T: FloatingPoint & TensorFlowScalar>(
+  origInputShape: Tensor<Int32>,
+  grad: Tensor<T>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat1 = .ndhwc
+) -> Tensor<T> {
+  let op = TFE_Op("AvgPool3DGrad")
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(origInputShape)
+  let _ = op.addInput(grad)
+  return op.execute(Int(1))
+}
+
+/// Computes gradients of the average pooling function.
+///
+/// - Parameters:
+///   - orig_input_shape: 1-D.  Shape of the original input to `avg_pool`.
+///   - grad: 4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t.
+///     the output of `avg_pool`.
+///
+/// - Attrs:
+///   - ksize: The size of the sliding window for each dimension of the input.
+///   - strides: The stride of the sliding window for each dimension of the input.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, in_channels, in_height, in_width].
+///
+/// - Output output: 4-D.  Gradients w.r.t. the input of `avg_pool`.
+@inlinable @inline(__always)
+public static func avgPoolGrad<T: FloatingPoint & TensorFlowScalar>(
+  origInputShape: Tensor<Int32>,
+  grad: Tensor<T>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let op = TFE_Op("AvgPoolGrad")
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(origInputShape)
+  let _ = op.addInput(grad)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func b(
+) -> Tensor<Float> {
+  let op = TFE_Op("B")
+  
+  return op.execute(Int(1))
+}
+
+/// Batches all input tensors nondeterministically.
+///
+/// When many instances of this Op are being run concurrently with the same
+/// container/shared_name in the same device, some will output zero-shaped Tensors
+/// and others will output Tensors of size up to max_batch_size.
+///
+/// All Tensors in in_tensors are batched together (so, for example, labels and
+/// features should be batched with a single instance of this operation.
+///
+/// Each invocation of batch emits an `id` scalar which will be used to identify
+/// this particular invocation when doing unbatch or its gradient.
+///
+/// Each op which emits a non-empty batch will also emit a non-empty batch_index
+/// Tensor, which, is a [K, 3] matrix where each row contains the invocation's id,
+/// start, and length of elements of each set of Tensors present in batched_tensors.
+///
+/// Batched tensors are concatenated along the first dimension, and all tensors in
+/// in_tensors must have the first dimension of the same size.
+///
+/// in_tensors: The tensors to be batched.
+/// num_batch_threads: Number of scheduling threads for processing batches of work.
+///  Determines the number of batches processed in parallel.
+/// max_batch_size: Batch sizes will never be bigger than this.
+/// batch_timeout_micros: Maximum number of microseconds to wait before outputting
+///  an incomplete batch.
+/// allowed_batch_sizes: Optional list of allowed batch sizes. If left empty, does
+///  nothing. Otherwise, supplies a list of batch sizes, causing the op to pad
+///  batches up to one of those sizes. The entries must increase monotonically, and
+///  the final entry must equal max_batch_size.
+/// grad_timeout_micros: The timeout to use for the gradient. See Unbatch.
+/// batched_tensors: Either empty tensors or a batch of concatenated Tensors.
+/// batch_index: If out_tensors is non-empty, has information to invert it.
+/// container: Controls the scope of sharing of this batch.
+/// id: always contains a scalar with a unique ID for this invocation of Batch.
+/// shared_name: Concurrently running instances of batch in the same device with the
+///  same container and shared_name will batch their elements together. If left
+///  empty, the op name will be used as the shared name.
+/// T: the types of tensors to be batched.
+@inlinable @inline(__always)
+public static func batch<T: TensorArrayProtocol>(
+  inTensors: T,
+  numBatchThreads: Int64,
+  maxBatchSize: Int64,
+  maxEnqueuedBatches: Int64 = 10,
+  batchTimeoutMicros: Int64,
+  allowedBatchSizes: [Int32],
+  gradTimeoutMicros: Int64,
+  container: String,
+  sharedName: String,
+  batchingQueue: String
+) -> (batchedTensors: T, batchIndex: Tensor<Int64>, id: Tensor<Int64>) {
+  let op = TFE_Op("Batch")
+  op.setAttr("num_batch_threads", numBatchThreads)
+  op.setAttr("max_batch_size", maxBatchSize)
+  op.setAttr("max_enqueued_batches", maxEnqueuedBatches)
+  op.setAttr("batch_timeout_micros", batchTimeoutMicros)
+  op.setAttr("allowed_batch_sizes", allowedBatchSizes)
+  op.setAttr("grad_timeout_micros", gradTimeoutMicros)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("batching_queue", batchingQueue)
+  op.setAttr("T", inTensors._typeList)
+  let _ = op.addInputList(inTensors)
+  return op.execute(Int(inTensors._typeList.count), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchCholesky<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BatchCholesky")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchCholeskyGrad<T: FloatingPoint & TensorFlowScalar>(
+  l: Tensor<T>,
+  grad: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BatchCholeskyGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(l)
+  let _ = op.addInput(grad)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that batches `batch_size` elements from `input_dataset`.
+///
+/// - Parameter batch_size: A scalar representing the number of elements to accumulate in a
+///   batch.
+@inlinable @inline(__always)
+public static func batchDataset(
+  inputDataset: VariantHandle,
+  batchSize: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("BatchDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(batchSize)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that batches `batch_size` elements from `input_dataset`.
+///
+/// - Parameters:
+///   - batch_size: A scalar representing the number of elements to accumulate in a batch.
+///   - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
+///     is smaller than desired.
+@inlinable @inline(__always)
+public static func batchDatasetV2(
+  inputDataset: VariantHandle,
+  batchSize: Tensor<Int64>,
+  dropRemainder: Tensor<Bool>,
+  parallelCopy: Bool = false,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("BatchDatasetV2")
+  op.setAttr("parallel_copy", parallelCopy)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(batchSize)
+  let _ = op.addInput(dropRemainder)
+  return op.execute(Int(1))
+}
+
+/// Batches all the inputs tensors to the computation done by the function.
+///
+/// So, for example, in the following code
+///
+///   ```python
+///
+///   # This input will be captured.
+///   y = tf.placeholder_with_default(1.0, shape=[])
+///
+///   @tf.Defun(tf.float32)
+///   def computation(a):
+///     return tf.matmul(a, a) + y
+///
+///   b = gen_batch_ops.batch_function(
+///           f=computation
+///           in_tensors=[a],
+///           captured_tensors=computation.captured_inputs,
+///           Tout=[o.type for o in computation.definition.signature.output_arg],
+///           num_batch_threads=1,
+///           max_batch_size=10,
+///           batch_timeout_micros=100000,  # 100ms
+///           allowed_batch_sizes=[3, 10],
+///           batching_queue="")
+///
+/// If more than one session.run call is simultaneously trying to compute `b`
+/// the values of `a` will be gathered, non-deterministically concatenated
+/// along the first axis, and only one thread will run the computation.
+///
+/// Assumes that all arguments of the function are Tensors which will be batched
+/// along their first dimension.
+///
+/// Arguments that are captured, are not batched. The session.run call which does
+/// the concatenation, will use the values of the captured tensors available to it.
+/// Therefore, typical uses of captured tensors should involve values which remain
+/// unchanged across session.run calls. Inference is a good example of this.
+///
+/// SparseTensor is not supported. The return value of the decorated function
+/// must be a Tensor or a list/tuple of Tensors.
+///
+/// - Parameters:
+///   - in_tensors: The tensors to be batched.
+///   - captured_tensors: The tensors which are captured in the function, and don't need
+///     to be batched.
+///
+/// - Attrs:
+///   - num_batch_threads: Number of scheduling threads for processing batches of work.
+///     Determines the number of batches processed in parallel.
+///   - max_batch_size: Batch sizes will never be bigger than this.
+///   - batch_timeout_micros: Maximum number of microseconds to wait before outputting
+///     an incomplete batch.
+///   - max_enqueued_batches: Maximum number of batches enqueued. Default: 10.
+///   - allowed_batch_sizes: Optional list of allowed batch sizes. If left empty, does
+///     nothing. Otherwise, supplies a list of batch sizes, causing the op to pad
+///     batches up to one of those sizes. The entries must increase monotonically, and
+///     the final entry must equal max_batch_size.
+///   - container: Controls the scope of sharing of this batch.
+///   - shared_name: Concurrently running instances of batch in the same device with the
+///     same container and shared_name will batch their elements together. If left
+///     empty, the op name will be used as the shared name.
+///   - Tin: the types of tensors to be batched.
+///   - Tcaptured: the types of the captured tensors.
+///   - Tout: the types of the output tensors.
+///
+/// - Output out_tensors: The output tensors.
+@inlinable @inline(__always)
+public static func batchFunction<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Tin: TensorArrayProtocol,
+    Tcaptured: TensorArrayProtocol,
+    Tout: TensorGroup
+>(
+  inTensors: Tin,
+  capturedTensors: Tcaptured,
+  f: (FIn) -> FOut,
+  numBatchThreads: Int64,
+  maxBatchSize: Int64,
+  batchTimeoutMicros: Int64,
+  maxEnqueuedBatches: Int64 = 10,
+  allowedBatchSizes: [Int32],
+  container: String,
+  sharedName: String,
+  batchingQueue: String
+) -> Tout {
+  let op = TFE_Op("BatchFunction")
+  op.setAttr("f", f)
+  op.setAttr("num_batch_threads", numBatchThreads)
+  op.setAttr("max_batch_size", maxBatchSize)
+  op.setAttr("batch_timeout_micros", batchTimeoutMicros)
+  op.setAttr("max_enqueued_batches", maxEnqueuedBatches)
+  op.setAttr("allowed_batch_sizes", allowedBatchSizes)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("batching_queue", batchingQueue)
+  op.setAttr("Tin", inTensors._typeList)
+  op.setAttr("Tcaptured", capturedTensors._typeList)
+  op.setAttr("Tout", Tout._typeList)
+  let _ = op.addInputList(inTensors)
+  let _ = op.addInputList(capturedTensors)
+  return op.execute(Int(Tout._typeList.count))
+}
+
+/// Multiplies slices of two tensors in batches.
+///
+/// Multiplies all slices of `Tensor` `x` and `y` (each slice can be
+/// viewed as an element of a batch), and arranges the individual results
+/// in a single output tensor of the same batch size. Each of the
+/// individual slices can optionally be adjointed (to adjoint a matrix
+/// means to transpose and conjugate it) before multiplication by setting
+/// the `adj_x` or `adj_y` flag to `True`, which are by default `False`.
+///
+/// The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]`
+/// and `[..., r_y, c_y]`.
+///
+/// The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where:
+///
+///     r_o = c_x if adj_x else r_x
+///     c_o = r_y if adj_y else c_y
+///
+/// It is computed as:
+///
+///     output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])
+///
+/// - Parameters:
+///   - x: 2-D or higher with shape `[..., r_x, c_x]`.
+///   - y: 2-D or higher with shape `[..., r_y, c_y]`.
+///
+/// - Attrs:
+///   - adj_x: If `True`, adjoint the slices of `x`. Defaults to `False`.
+///   - adj_y: If `True`, adjoint the slices of `y`. Defaults to `False`.
+///
+/// - Output output: 3-D or higher with shape `[..., r_o, c_o]`
+@inlinable @inline(__always)
+public static func batchMatMul<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>,
+  adjX: Bool = false,
+  adjY: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("BatchMatMul")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("adj_x", adjX)
+  op.setAttr("adj_y", adjY)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Multiplies slices of two tensors in batches.
+///
+/// Multiplies all slices of `Tensor` `x` and `y` (each slice can be
+/// viewed as an element of a batch), and arranges the individual results
+/// in a single output tensor of the same batch size. Each of the
+/// individual slices can optionally be adjointed (to adjoint a matrix
+/// means to transpose and conjugate it) before multiplication by setting
+/// the `adj_x` or `adj_y` flag to `True`, which are by default `False`.
+///
+/// The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]`
+/// and `[..., r_y, c_y]`.
+///
+/// The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where:
+///
+///     r_o = c_x if adj_x else r_x
+///     c_o = r_y if adj_y else c_y
+///
+/// It is computed as:
+///
+///     output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])
+///
+/// *NOTE*: `BatchMatMulV2` supports broadcasting in the batch dimensions. More
+/// about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html).
+///
+///
+/// - Parameters:
+///   - x: 2-D or higher with shape `[..., r_x, c_x]`.
+///   - y: 2-D or higher with shape `[..., r_y, c_y]`.
+///
+/// - Attrs:
+///   - adj_x: If `True`, adjoint the slices of `x`. Defaults to `False`.
+///   - adj_y: If `True`, adjoint the slices of `y`. Defaults to `False`.
+///
+/// - Output output: 3-D or higher with shape `[..., r_o, c_o]`
+@inlinable @inline(__always)
+public static func batchMatMulV2<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>,
+  adjX: Bool = false,
+  adjY: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("BatchMatMulV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("adj_x", adjX)
+  op.setAttr("adj_y", adjY)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixBandPart<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  numLower: Tensor<Int64>,
+  numUpper: Tensor<Int64>
+) -> Tensor<T> {
+  let op = TFE_Op("BatchMatrixBandPart")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(numLower)
+  let _ = op.addInput(numUpper)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BatchMatrixDeterminant")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixDiag<T: TensorFlowScalar>(
+  diagonal: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BatchMatrixDiag")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(diagonal)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixDiagPart<T: TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BatchMatrixDiagPart")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixInverse<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  adjoint: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("BatchMatrixInverse")
+  op.setAttr("adjoint", adjoint)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixSetDiag<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  diagonal: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BatchMatrixSetDiag")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(diagonal)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixSolve<T: FloatingPoint & TensorFlowScalar>(
+  matrix: Tensor<T>,
+  rhs: Tensor<T>,
+  adjoint: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("BatchMatrixSolve")
+  op.setAttr("adjoint", adjoint)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(matrix)
+  let _ = op.addInput(rhs)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixSolveLs<T: FloatingPoint & TensorFlowScalar>(
+  matrix: Tensor<T>,
+  rhs: Tensor<T>,
+  l2Regularizer: Tensor<Double>,
+  fast: Bool = true
+) -> Tensor<T> {
+  let op = TFE_Op("BatchMatrixSolveLs")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("fast", fast)
+  let _ = op.addInput(matrix)
+  let _ = op.addInput(rhs)
+  let _ = op.addInput(l2Regularizer)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixTriangularSolve<T: FloatingPoint & TensorFlowScalar>(
+  matrix: Tensor<T>,
+  rhs: Tensor<T>,
+  lower: Bool = true,
+  adjoint: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("BatchMatrixTriangularSolve")
+  op.setAttr("lower", lower)
+  op.setAttr("adjoint", adjoint)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(matrix)
+  let _ = op.addInput(rhs)
+  return op.execute(Int(1))
+}
+
+/// Batch normalization.
+///
+/// This op is deprecated. Prefer `tf.nn.batch_normalization`.
+///
+/// - Parameters:
+///   - t: A 4D input Tensor.
+///   - m: A 1D mean Tensor with size matching the last dimension of t.
+///     This is the first output from tf.nn.moments,
+///     or a saved moving average thereof.
+///   - v: A 1D variance Tensor with size matching the last dimension of t.
+///     This is the second output from tf.nn.moments,
+///     or a saved moving average thereof.
+///   - beta: A 1D beta Tensor with size matching the last dimension of t.
+///     An offset to be added to the normalized tensor.
+///   - gamma: A 1D gamma Tensor with size matching the last dimension of t.
+///     If "scale_after_normalization" is true, this tensor will be multiplied
+///     with the normalized tensor.
+///
+/// - Attrs:
+///   - variance_epsilon: A small float number to avoid dividing by 0.
+///   - scale_after_normalization: A bool indicating whether the resulted tensor
+///     needs to be multiplied with gamma.
+@inlinable @inline(__always)
+public static func batchNormWithGlobalNormalization<T: Numeric & TensorFlowScalar>(
+  t: Tensor<T>,
+  m: Tensor<T>,
+  v: Tensor<T>,
+  beta: Tensor<T>,
+  gamma: Tensor<T>,
+  varianceEpsilon: Double,
+  scaleAfterNormalization: Bool
+) -> Tensor<T> {
+  let op = TFE_Op("BatchNormWithGlobalNormalization")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("variance_epsilon", varianceEpsilon)
+  op.setAttr("scale_after_normalization", scaleAfterNormalization)
+  let _ = op.addInput(t)
+  let _ = op.addInput(m)
+  let _ = op.addInput(v)
+  let _ = op.addInput(beta)
+  let _ = op.addInput(gamma)
+  return op.execute(Int(1))
+}
+
+/// Gradients for batch normalization.
+///
+/// This op is deprecated. See `tf.nn.batch_normalization`.
+///
+/// - Parameters:
+///   - t: A 4D input Tensor.
+///   - m: A 1D mean Tensor with size matching the last dimension of t.
+///     This is the first output from tf.nn.moments,
+///     or a saved moving average thereof.
+///   - v: A 1D variance Tensor with size matching the last dimension of t.
+///     This is the second output from tf.nn.moments,
+///     or a saved moving average thereof.
+///   - gamma: A 1D gamma Tensor with size matching the last dimension of t.
+///     If "scale_after_normalization" is true, this Tensor will be multiplied
+///     with the normalized Tensor.
+///   - backprop: 4D backprop Tensor.
+///
+/// - Attrs:
+///   - variance_epsilon: A small float number to avoid dividing by 0.
+///   - scale_after_normalization: A bool indicating whether the resulted tensor
+///     needs to be multiplied with gamma.
+///
+/// - Outputs:
+///   - dx: 4D backprop tensor for input.
+///   - dm: 1D backprop tensor for mean.
+///   - dv: 1D backprop tensor for variance.
+///   - db: 1D backprop tensor for beta.
+///   - dg: 1D backprop tensor for gamma.
+@inlinable @inline(__always)
+public static func batchNormWithGlobalNormalizationGrad<T: Numeric & TensorFlowScalar>(
+  t: Tensor<T>,
+  m: Tensor<T>,
+  v: Tensor<T>,
+  gamma: Tensor<T>,
+  backprop: Tensor<T>,
+  varianceEpsilon: Double,
+  scaleAfterNormalization: Bool
+) -> (dx: Tensor<T>, dm: Tensor<T>, dv: Tensor<T>, db: Tensor<T>, dg: Tensor<T>) {
+  let op = TFE_Op("BatchNormWithGlobalNormalizationGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("variance_epsilon", varianceEpsilon)
+  op.setAttr("scale_after_normalization", scaleAfterNormalization)
+  let _ = op.addInput(t)
+  let _ = op.addInput(m)
+  let _ = op.addInput(v)
+  let _ = op.addInput(gamma)
+  let _ = op.addInput(backprop)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchSelfAdjointEig<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BatchSelfAdjointEig")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchSelfAdjointEigV2<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  computeV: Bool = true
+) -> (e: Tensor<T>, v: Tensor<T>) {
+  let op = TFE_Op("BatchSelfAdjointEigV2")
+  op.setAttr("compute_v", computeV)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchSvd<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  computeUv: Bool = true,
+  fullMatrices: Bool = false
+) -> (s: Tensor<T>, u: Tensor<T>, v: Tensor<T>) {
+  let op = TFE_Op("BatchSvd")
+  op.setAttr("compute_uv", computeUv)
+  op.setAttr("full_matrices", fullMatrices)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// BatchToSpace for 4-D tensors of type T.
+///
+/// This is a legacy version of the more general BatchToSpaceND.
+///
+/// Rearranges (permutes) data from batch into blocks of spatial data, followed by
+/// cropping. This is the reverse transformation of SpaceToBatch. More specifically,
+/// this op outputs a copy of the input tensor where values from the `batch`
+/// dimension are moved in spatial blocks to the `height` and `width` dimensions,
+/// followed by cropping along the `height` and `width` dimensions.
+///
+/// - Parameters:
+///   - input: 4-D tensor with shape
+///     `[batch*block_size*block_size, height_pad/block_size, width_pad/block_size,
+///       depth]`. Note that the batch size of the input tensor must be divisible by
+///     `block_size * block_size`.
+///   - crops: 2-D tensor of non-negative integers with shape `[2, 2]`. It specifies
+///     how many elements to crop from the intermediate result across the spatial
+///     dimensions as follows:
+///
+///         crops = [[crop_top, crop_bottom], [crop_left, crop_right]]
+///
+/// - Output output: 4-D with shape `[batch, height, width, depth]`, where:
+///
+///         height = height_pad - crop_top - crop_bottom
+///         width = width_pad - crop_left - crop_right
+///
+///   The attr `block_size` must be greater than one. It indicates the block size.
+///
+///   Some examples:
+///
+///   (1) For the following input of shape `[4, 1, 1, 1]` and block_size of 2:
+///
+///   ```
+///   [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+///   ```
+///
+///   The output tensor has shape `[1, 2, 2, 1]` and value:
+///
+///   ```
+///   x = [[[[1], [2]], [[3], [4]]]]
+///   ```
+///
+///   (2) For the following input of shape `[4, 1, 1, 3]` and block_size of 2:
+///
+///   ```
+///   [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
+///   ```
+///
+///   The output tensor has shape `[1, 2, 2, 3]` and value:
+///
+///   ```
+///   x = [[[[1, 2, 3], [4, 5, 6]],
+///         [[7, 8, 9], [10, 11, 12]]]]
+///   ```
+///
+///   (3) For the following input of shape `[4, 2, 2, 1]` and block_size of 2:
+///
+///   ```
+///   x = [[[[1], [3]], [[9], [11]]],
+///        [[[2], [4]], [[10], [12]]],
+///        [[[5], [7]], [[13], [15]]],
+///        [[[6], [8]], [[14], [16]]]]
+///   ```
+///
+///   The output tensor has shape `[1, 4, 4, 1]` and value:
+///
+///   ```
+///   x = [[[[1],   [2],  [3],  [4]],
+///        [[5],   [6],  [7],  [8]],
+///        [[9],  [10], [11],  [12]],
+///        [[13], [14], [15],  [16]]]]
+///   ```
+///
+///   (4) For the following input of shape `[8, 1, 2, 1]` and block_size of 2:
+///
+///   ```
+///   x = [[[[1], [3]]], [[[9], [11]]], [[[2], [4]]], [[[10], [12]]],
+///        [[[5], [7]]], [[[13], [15]]], [[[6], [8]]], [[[14], [16]]]]
+///   ```
+///
+///   The output tensor has shape `[2, 2, 4, 1]` and value:
+///
+///   ```
+///   x = [[[[1], [3]], [[5], [7]]],
+///        [[[2], [4]], [[10], [12]]],
+///        [[[5], [7]], [[13], [15]]],
+///        [[[6], [8]], [[14], [16]]]]
+///   ```
+@inlinable @inline(__always)
+public static func batchToSpace<
+    T: TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  crops: Tensor<Tidx>,
+  blockSize: Int64
+) -> Tensor<T> {
+  let op = TFE_Op("BatchToSpace")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("block_size", blockSize)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(crops)
+  return op.execute(Int(1))
+}
+
+/// BatchToSpace for N-D tensors of type T.
+///
+/// This operation reshapes the "batch" dimension 0 into `M + 1` dimensions of shape
+/// `block_shape + [batch]`, interleaves these blocks back into the grid defined by
+/// the spatial dimensions `[1, ..., M]`, to obtain a result with the same rank as
+/// the input.  The spatial dimensions of this intermediate result are then
+/// optionally cropped according to `crops` to produce the output.  This is the
+/// reverse of SpaceToBatch.  See below for a precise description.
+///
+/// - Parameters:
+///   - input: N-D with shape `input_shape = [batch] + spatial_shape + remaining_shape`,
+///     where spatial_shape has M dimensions.
+///   - block_shape: 1-D with shape `[M]`, all values must be >= 1.
+///   - crops: 2-D with shape `[M, 2]`, all values must be >= 0.
+///       `crops[i] = [crop_start, crop_end]` specifies the amount to crop from input
+///       dimension `i + 1`, which corresponds to spatial dimension `i`.  It is
+///       required that
+///       `crop_start[i] + crop_end[i] <= block_shape[i] * input_shape[i + 1]`.
+///
+///     This operation is equivalent to the following steps:
+///
+///     1. Reshape `input` to `reshaped` of shape:
+///          [block_shape[0], ..., block_shape[M-1],
+///           batch / prod(block_shape),
+///           input_shape[1], ..., input_shape[N-1]]
+///
+///     2. Permute dimensions of `reshaped` to produce `permuted` of shape
+///          [batch / prod(block_shape),
+///
+///           input_shape[1], block_shape[0],
+///           ...,
+///           input_shape[M], block_shape[M-1],
+///
+///           input_shape[M+1], ..., input_shape[N-1]]
+///
+///     3. Reshape `permuted` to produce `reshaped_permuted` of shape
+///          [batch / prod(block_shape),
+///
+///           input_shape[1] * block_shape[0],
+///           ...,
+///           input_shape[M] * block_shape[M-1],
+///
+///           input_shape[M+1],
+///           ...,
+///           input_shape[N-1]]
+///
+///     4. Crop the start and end of dimensions `[1, ..., M]` of
+///        `reshaped_permuted` according to `crops` to produce the output of shape:
+///          [batch / prod(block_shape),
+///
+///           input_shape[1] * block_shape[0] - crops[0,0] - crops[0,1],
+///           ...,
+///           input_shape[M] * block_shape[M-1] - crops[M-1,0] - crops[M-1,1],
+///
+///           input_shape[M+1], ..., input_shape[N-1]]
+///
+///     Some examples:
+///
+///     (1) For the following input of shape `[4, 1, 1, 1]`, `block_shape = [2, 2]`, and
+///         `crops = [[0, 0], [0, 0]]`:
+///
+///     ```
+///     [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+///     ```
+///
+///     The output tensor has shape `[1, 2, 2, 1]` and value:
+///
+///     ```
+///     x = [[[[1], [2]], [[3], [4]]]]
+///     ```
+///
+///     (2) For the following input of shape `[4, 1, 1, 3]`, `block_shape = [2, 2]`, and
+///         `crops = [[0, 0], [0, 0]]`:
+///
+///     ```
+///     [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
+///     ```
+///
+///     The output tensor has shape `[1, 2, 2, 3]` and value:
+///
+///     ```
+///     x = [[[[1, 2, 3], [4, 5, 6]],
+///           [[7, 8, 9], [10, 11, 12]]]]
+///     ```
+///
+///     (3) For the following input of shape `[4, 2, 2, 1]`, `block_shape = [2, 2]`, and
+///         `crops = [[0, 0], [0, 0]]`:
+///
+///     ```
+///     x = [[[[1], [3]], [[9], [11]]],
+///          [[[2], [4]], [[10], [12]]],
+///          [[[5], [7]], [[13], [15]]],
+///          [[[6], [8]], [[14], [16]]]]
+///     ```
+///
+///     The output tensor has shape `[1, 4, 4, 1]` and value:
+///
+///     ```
+///     x = [[[[1],   [2],  [3],  [4]],
+///          [[5],   [6],  [7],  [8]],
+///          [[9],  [10], [11],  [12]],
+///          [[13], [14], [15],  [16]]]]
+///     ```
+///
+///     (4) For the following input of shape `[8, 1, 3, 1]`, `block_shape = [2, 2]`, and
+///         `crops = [[0, 0], [2, 0]]`:
+///
+///     ```
+///     x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
+///          [[[0], [2], [4]]], [[[0], [10], [12]]],
+///          [[[0], [5], [7]]], [[[0], [13], [15]]],
+///          [[[0], [6], [8]]], [[[0], [14], [16]]]]
+///     ```
+///
+///     The output tensor has shape `[2, 2, 4, 1]` and value:
+///
+///     ```
+///     x = [[[[1],   [2],  [3],  [4]],
+///           [[5],   [6],  [7],  [8]]],
+///          [[[9],  [10], [11],  [12]],
+///           [[13], [14], [15],  [16]]]]
+///     ```
+@inlinable @inline(__always)
+public static func batchToSpaceND<
+    T: TensorFlowScalar,
+    TblockShape: BinaryInteger & TensorFlowScalar,
+    Tcrops: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  blockShape: Tensor<TblockShape>,
+  crops: Tensor<Tcrops>
+) -> Tensor<T> {
+  let op = TFE_Op("BatchToSpaceND")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tblock_shape", TblockShape.tensorFlowDataType)
+  op.setAttr("Tcrops", Tcrops.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(blockShape)
+  let _ = op.addInput(crops)
+  return op.execute(Int(1))
+}
+
+/// Computes the Bessel i0e function of `x` element-wise.
+///
+/// Exponentially scaled modified Bessel function of order 0 defined as
+/// `bessel_i0e(x) = exp(-abs(x)) bessel_i0(x)`.
+///
+/// This function is faster and numerically stabler than `bessel_i0(x)`.
+@inlinable @inline(__always)
+public static func besselI0e<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BesselI0e")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the Bessel i1e function of `x` element-wise.
+///
+/// Exponentially scaled modified Bessel function of order 0 defined as
+/// `bessel_i1e(x) = exp(-abs(x)) bessel_i1(x)`.
+///
+/// This function is faster and numerically stabler than `bessel_i1(x)`.
+@inlinable @inline(__always)
+public static func besselI1e<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BesselI1e")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Compute the regularized incomplete beta integral \\(I_x(a, b)\\).
+///
+/// The regularized incomplete beta integral is defined as:
+///
+///
+/// \\(I_x(a, b) = \frac{B(x; a, b)}{B(a, b)}\\)
+///
+/// where
+///
+///
+/// \\(B(x; a, b) = \int_0^x t^{a-1} (1 - t)^{b-1} dt\\)
+///
+///
+/// is the incomplete beta function and \\(B(a, b)\\) is the *complete*
+/// beta function.
+@inlinable @inline(__always)
+public static func betainc<T: FloatingPoint & TensorFlowScalar>(
+  _ a: Tensor<T>,
+  _ b: Tensor<T>,
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Betainc")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Adds `bias` to `value`.
+///
+/// This is a special case of `tf.add` where `bias` is restricted to be 1-D.
+/// Broadcasting is supported, so `value` may have any number of dimensions.
+///
+/// - Parameters:
+///   - value: Any number of dimensions.
+///   - bias: 1-D with size the last dimension of `value`.
+///
+/// - Attr data_format: Specify the data format of the input and output data. With the
+///   default format "NHWC", the bias tensor will be added to the last dimension
+///   of the value tensor.
+///   Alternatively, the format could be "NCHW", the data storage order of:
+///       [batch, in_channels, in_height, in_width].
+///   The tensor will be added to "in_channels", the third-to-the-last
+///       dimension.
+///
+/// - Output output: Broadcasted sum of `value` and `bias`.
+@inlinable @inline(__always)
+public static func biasAdd<T: Numeric & TensorFlowScalar>(
+  value: Tensor<T>,
+  bias: Tensor<T>,
+  dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let op = TFE_Op("BiasAdd")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("data_format", dataFormat.cName)
+  let _ = op.addInput(value)
+  let _ = op.addInput(bias)
+  return op.execute(Int(1))
+}
+
+/// The backward operation for "BiasAdd" on the "bias" tensor.
+///
+/// It accumulates all the values from out_backprop into the feature dimension.
+/// For NHWC data format, the feature dimension is the last. For NCHW data format,
+/// the feature dimension is the third-to-last.
+///
+/// - Parameter out_backprop: Any number of dimensions.
+///
+/// - Attr data_format: Specify the data format of the input and output data. With the
+///   default format "NHWC", the bias tensor will be added to the last dimension
+///   of the value tensor.
+///   Alternatively, the format could be "NCHW", the data storage order of:
+///       [batch, in_channels, in_height, in_width].
+///   The tensor will be added to "in_channels", the third-to-the-last
+///       dimension.
+///
+/// - Output output: 1-D with size the feature dimension of `out_backprop`.
+@inlinable @inline(__always)
+public static func biasAddGrad<T: Numeric & TensorFlowScalar>(
+  outBackprop: Tensor<T>,
+  dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let op = TFE_Op("BiasAddGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("data_format", dataFormat.cName)
+  let _ = op.addInput(outBackprop)
+  return op.execute(Int(1))
+}
+
+/// Adds `bias` to `value`.
+///
+/// This is a deprecated version of BiasAdd and will be soon removed.
+///
+/// This is a special case of `tf.add` where `bias` is restricted to be 1-D.
+/// Broadcasting is supported, so `value` may have any number of dimensions.
+///
+/// - Parameters:
+///   - value: Any number of dimensions.
+///   - bias: 1-D with size the last dimension of `value`.
+///
+/// - Output output: Broadcasted sum of `value` and `bias`.
+@inlinable @inline(__always)
+public static func biasAddV1<T: Numeric & TensorFlowScalar>(
+  value: Tensor<T>,
+  bias: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BiasAddV1")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(value)
+  let _ = op.addInput(bias)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func binary<T: TensorFlowScalar>(
+  _ a: Tensor<T>,
+  _ b: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Binary")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  return op.execute(Int(1))
+}
+
+/// Counts the number of occurrences of each value in an integer array.
+///
+/// Outputs a vector with length `size` and the same dtype as `weights`. If
+/// `weights` are empty, then index `i` stores the number of times the value `i` is
+/// counted in `arr`. If `weights` are non-empty, then index `i` stores the sum of
+/// the value in `weights` at each index where the corresponding value in `arr` is
+/// `i`.
+///
+/// Values in `arr` outside of the range [0, size) are ignored.
+///
+/// - Parameters:
+///   - arr: int32 `Tensor`.
+///   - size: non-negative int32 scalar `Tensor`.
+///   - weights: is an int32, int64, float32, or float64 `Tensor` with the same
+///     shape as `arr`, or a length-0 `Tensor`, in which case it acts as all weights
+///     equal to 1.
+///
+/// - Output bins: 1D `Tensor` with length equal to `size`. The counts or summed weights for
+///   each value in the range [0, size).
+@inlinable @inline(__always)
+public static func bincount<T: Numeric & TensorFlowScalar>(
+  arr: Tensor<Int32>,
+  size: Tensor<Int32>,
+  weights: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Bincount")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(arr)
+  let _ = op.addInput(size)
+  let _ = op.addInput(weights)
+  return op.execute(Int(1))
+}
+
+/// Bitcasts a tensor from one type to another without copying data.
+///
+/// Given a tensor `input`, this operation returns a tensor that has the same buffer
+/// data as `input` with datatype `type`.
+///
+/// If the input datatype `T` is larger than the output datatype `type` then the
+/// shape changes from [...] to [..., sizeof(`T`)/sizeof(`type`)].
+///
+/// If `T` is smaller than `type`, the operator requires that the rightmost
+/// dimension be equal to sizeof(`type`)/sizeof(`T`). The shape then goes from
+/// [..., sizeof(`type`)/sizeof(`T`)] to [...].
+///
+/// tf.bitcast() and tf.cast() work differently when real dtype is casted as a complex dtype
+/// (e.g. tf.complex64 or tf.complex128) as tf.cast() make imaginary part 0 while tf.bitcast()
+/// gives module error.
+/// For example,
+///
+/// Example 1:
+/// ```python
+/// >>> a = [1., 2., 3.]
+/// >>> equality_bitcast = tf.bitcast(a,tf.complex128)
+/// tensorflow.python.framework.errors_impl.InvalidArgumentError: Cannot bitcast from float to complex128: shape [3] [Op:Bitcast]
+/// >>> equality_cast = tf.cast(a,tf.complex128)
+/// >>> print(equality_cast)
+/// tf.Tensor([1.+0.j 2.+0.j 3.+0.j], shape=(3,), dtype=complex128)
+/// ```
+/// Example 2:
+/// ```python
+/// >>> tf.bitcast(tf.constant(0xffffffff, dtype=tf.uint32), tf.uint8)
+/// <tf.Tensor: ... shape=(4,), dtype=uint8, numpy=array([255, 255, 255, 255], dtype=uint8)>
+/// ```
+/// Example 3:
+/// ```python
+/// >>> x = [1., 2., 3.]
+/// >>> y = [0., 2., 3.]
+/// >>> equality= tf.equal(x,y)
+/// >>> equality_cast = tf.cast(equality,tf.float32)
+/// >>> equality_bitcast = tf.bitcast(equality_cast,tf.uint8)
+/// >>> print(equality)
+/// tf.Tensor([False True True], shape=(3,), dtype=bool)
+/// >>> print(equality_cast)
+/// tf.Tensor([0. 1. 1.], shape=(3,), dtype=float32)
+/// >>> print(equality_bitcast)
+/// tf.Tensor(
+/// [[ 0 0 0 0]
+///  [ 0 0 128 63]
+///  [ 0 0 128 63]], shape=(3, 4), dtype=uint8)
+/// ```
+///
+/// *NOTE*: Bitcast is implemented as a low-level cast, so machines with different
+/// endian orderings will give different results.
+@inlinable @inline(__always)
+public static func bitcast<
+    T: Numeric & TensorFlowScalar,
+    Type: Numeric & TensorFlowScalar
+>(
+  _ input: Tensor<T>
+) -> Tensor<Type> {
+  let op = TFE_Op("Bitcast")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("type", Type.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Elementwise computes the bitwise AND of `x` and `y`.
+///
+/// The result will have those bits set, that are set in both `x` and `y`. The
+/// computation is performed on the underlying representations of `x` and `y`.
+@inlinable @inline(__always)
+public static func bitwiseAnd<T: BinaryInteger & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BitwiseAnd")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Elementwise computes the bitwise OR of `x` and `y`.
+///
+/// The result will have those bits set, that are set in `x`, `y` or both. The
+/// computation is performed on the underlying representations of `x` and `y`.
+@inlinable @inline(__always)
+public static func bitwiseOr<T: BinaryInteger & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BitwiseOr")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Elementwise computes the bitwise XOR of `x` and `y`.
+///
+/// The result will have those bits set, that are different in `x` and `y`. The
+/// computation is performed on the underlying representations of `x` and `y`.
+@inlinable @inline(__always)
+public static func bitwiseXor<T: BinaryInteger & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BitwiseXor")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Computes the LSTM cell forward propagation for all the time steps.
+///
+/// This is equivalent to applying LSTMBlockCell in a loop, like so:
+///
+/// ```python
+/// for x1 in unpack(x):
+///   i1, cs1, f1, o1, ci1, co1, h1 = LSTMBlock(
+///     x1, cs_prev, h_prev, w, wci, wcf, wco, b)
+///   cs_prev = cs1
+///   h_prev = h1
+///   i.append(i1)
+///   cs.append(cs1)
+///   f.append(f1)
+///   o.append(o1)
+///   ci.append(ci1)
+///   co.append(co1)
+///   h.append(h1)
+/// return pack(i), pack(cs), pack(f), pack(o), pack(ci), pack(ch), pack(h)
+/// ```
+///
+/// - Parameters:
+///   - seq_len_max: Maximum time length actually used by this input. Outputs are padded
+///     with zeros beyond this length.
+///   - x: The sequence input to the LSTM, shape (timelen, batch_size, num_inputs).
+///   - cs_prev: Value of the initial cell state.
+///   - h_prev: Initial output of cell (to be used for peephole).
+///   - w: The weight matrix.
+///   - wci: The weight matrix for input gate peephole connection.
+///   - wcf: The weight matrix for forget gate peephole connection.
+///   - wco: The weight matrix for output gate peephole connection.
+///   - b: The bias vector.
+///
+/// - Attrs:
+///   - forget_bias: The forget gate bias.
+///   - cell_clip: Value to clip the 'cs' value to.
+///   - use_peephole: Whether to use peephole weights.
+///
+/// - Outputs:
+///   - i: The input gate over the whole time sequence.
+///   - cs: The cell state before the tanh over the whole time sequence.
+///   - f: The forget gate over the whole time sequence.
+///   - o: The output gate over the whole time sequence.
+///   - ci: The cell input over the whole time sequence.
+///   - co: The cell after the tanh over the whole time sequence.
+///   - h: The output h vector over the whole time sequence.
+@inlinable @inline(__always)
+public static func blockLSTM<T: FloatingPoint & TensorFlowScalar>(
+  seqLenMax: Tensor<Int64>,
+  _ x: Tensor<T>,
+  csPrev: Tensor<T>,
+  hPrev: Tensor<T>,
+  w: Tensor<T>,
+  wci: Tensor<T>,
+  wcf: Tensor<T>,
+  wco: Tensor<T>,
+  _ b: Tensor<T>,
+  forgetBias: Double = 1,
+  cellClip: Double = 3,
+  usePeephole: Bool = false
+) -> (i: Tensor<T>, cs: Tensor<T>, f: Tensor<T>, o: Tensor<T>, ci: Tensor<T>, co: Tensor<T>, h: Tensor<T>) {
+  let op = TFE_Op("BlockLSTM")
+  op.setAttr("forget_bias", forgetBias)
+  op.setAttr("cell_clip", cellClip)
+  op.setAttr("use_peephole", usePeephole)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(seqLenMax)
+  let _ = op.addInput(x)
+  let _ = op.addInput(csPrev)
+  let _ = op.addInput(hPrev)
+  let _ = op.addInput(w)
+  let _ = op.addInput(wci)
+  let _ = op.addInput(wcf)
+  let _ = op.addInput(wco)
+  let _ = op.addInput(b)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Computes the LSTM cell backward propagation for the entire time sequence.
+///
+/// This implementation is to be used in conjunction of LSTMBlock.
+///
+/// - Parameters:
+///   - seq_len_max: Maximum time length actually used by this input. Outputs are padded
+///     with zeros beyond this length.
+///   - x: The sequence input to the LSTM, shape (timelen, batch_size, num_inputs).
+///   - cs_prev: Value of the initial cell state.
+///   - h_prev: Initial output of cell (to be used for peephole).
+///   - w: The weight matrix.
+///   - wci: The weight matrix for input gate peephole connection.
+///   - wcf: The weight matrix for forget gate peephole connection.
+///   - wco: The weight matrix for output gate peephole connection.
+///   - b: The bias vector.
+///   - i: The input gate over the whole time sequence.
+///   - cs: The cell state before the tanh over the whole time sequence.
+///   - f: The forget gate over the whole time sequence.
+///   - o: The output gate over the whole time sequence.
+///   - ci: The cell input over the whole time sequence.
+///   - co: The cell after the tanh over the whole time sequence.
+///   - h: The output h vector over the whole time sequence.
+///   - cs_grad: The current gradient of cs.
+///   - h_grad: The gradient of h vector.
+///
+/// - Attr use_peephole: Whether to use peephole weights.
+///
+/// - Outputs:
+///   - x_grad: The gradient of x to be back-propped.
+///   - cs_prev_grad: The gradient of cs_prev to be back-propped.
+///   - h_prev_grad: The gradient of h_prev to be back-propped.
+///   - w_grad: The gradient for w to be back-propped.
+///   - wci_grad: The gradient for wci to be back-propped.
+///   - wcf_grad: The gradient for wcf to be back-propped.
+///   - wco_grad: The gradient for wco to be back-propped.
+///   - b_grad: The gradient for w to be back-propped.
+@inlinable @inline(__always)
+public static func blockLSTMGrad<T: FloatingPoint & TensorFlowScalar>(
+  seqLenMax: Tensor<Int64>,
+  _ x: Tensor<T>,
+  csPrev: Tensor<T>,
+  hPrev: Tensor<T>,
+  w: Tensor<T>,
+  wci: Tensor<T>,
+  wcf: Tensor<T>,
+  wco: Tensor<T>,
+  _ b: Tensor<T>,
+  i: Tensor<T>,
+  cs: Tensor<T>,
+  f: Tensor<T>,
+  o: Tensor<T>,
+  ci: Tensor<T>,
+  co: Tensor<T>,
+  h: Tensor<T>,
+  csGrad: Tensor<T>,
+  hGrad: Tensor<T>,
+  usePeephole: Bool
+) -> (xGrad: Tensor<T>, csPrevGrad: Tensor<T>, hPrevGrad: Tensor<T>, wGrad: Tensor<T>, wciGrad: Tensor<T>, wcfGrad: Tensor<T>, wcoGrad: Tensor<T>, bGrad: Tensor<T>) {
+  let op = TFE_Op("BlockLSTMGrad")
+  op.setAttr("use_peephole", usePeephole)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(seqLenMax)
+  let _ = op.addInput(x)
+  let _ = op.addInput(csPrev)
+  let _ = op.addInput(hPrev)
+  let _ = op.addInput(w)
+  let _ = op.addInput(wci)
+  let _ = op.addInput(wcf)
+  let _ = op.addInput(wco)
+  let _ = op.addInput(b)
+  let _ = op.addInput(i)
+  let _ = op.addInput(cs)
+  let _ = op.addInput(f)
+  let _ = op.addInput(o)
+  let _ = op.addInput(ci)
+  let _ = op.addInput(co)
+  let _ = op.addInput(h)
+  let _ = op.addInput(csGrad)
+  let _ = op.addInput(hGrad)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Aggregates the summary of accumulated stats for the batch.
+///
+/// The summary stats contains gradients and hessians accumulated for each node, feature dimension id and bucket.
+///
+/// - Parameters:
+///   - node_ids: int32; Rank 1 Tensor containing node ids for each example, shape [batch_size].
+///   - gradients: float32; Rank 2 Tensor (shape=[batch_size, logits_dimension]) with gradients for each example.
+///   - hessians: float32; Rank 2 Tensor (shape=[batch_size, hessian_dimension]) with hessians for each example.
+///   - feature: int32; Rank 2 feature Tensors (shape=[batch_size, feature_dimension]).
+///
+/// - Attrs:
+///   - max_splits: int; the maximum number of splits possible in the whole tree.
+///   - num_buckets: int; equals to the maximum possible value of bucketized feature.
+///
+/// - Output stats_summary: output Rank 4 Tensor (shape=[splits, feature_dimension, buckets, logits_dimension + hessian_dimension])
+///   containing accumulated stats for each node, feature dimension and bucket.
+@inlinable @inline(__always)
+public static func boostedTreesAggregateStats(
+  nodeIds: Tensor<Int32>,
+  gradients: Tensor<Float>,
+  hessians: Tensor<Float>,
+  feature: Tensor<Int32>,
+  maxSplits: Int64,
+  numBuckets: Int64
+) -> Tensor<Float> {
+  let op = TFE_Op("BoostedTreesAggregateStats")
+  op.setAttr("max_splits", maxSplits)
+  op.setAttr("num_buckets", numBuckets)
+  let _ = op.addInput(nodeIds)
+  let _ = op.addInput(gradients)
+  let _ = op.addInput(hessians)
+  let _ = op.addInput(feature)
+  return op.execute(Int(1))
+}
+
+/// Bucketize each feature based on bucket boundaries.
+///
+/// An op that returns a list of float tensors, where each tensor represents the
+/// bucketized values for a single feature.
+///
+/// - Parameters:
+///   - float_values: float; List of Rank 1 Tensor each containing float values for a single feature.
+///   - bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a single
+///     feature.
+///
+/// - Attr num_features: inferred int; number of features.
+///
+/// - Output buckets: int; List of Rank 1 Tensors each containing the bucketized values for a single feature.
+@inlinable @inline(__always)
+public static func boostedTreesBucketize(
+  floatValues: [Tensor<Float>],
+  bucketBoundaries: [Tensor<Float>]
+) -> [Tensor<Int32>] {
+  let op = TFE_Op("BoostedTreesBucketize")
+  op.setAttr("num_features", floatValues.count)
+  let _ = op.addInputList(floatValues)
+  let _ = op.addInputList(bucketBoundaries)
+  return op.execute(Int(floatValues.count))
+}
+
+/// Calculates gains for each feature and returns the best possible split information for the feature.
+///
+/// The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature.
+///
+/// It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split.
+///
+/// In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features).
+///
+/// The output shapes are compatible in a way that the first dimension of all tensors are the same and equal to the number of possible split nodes for each feature.
+///
+/// - Parameters:
+///   - node_id_range: A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive).
+///   - stats_summary: A Rank 4 tensor (#shape=[max_splits, feature_dims, bucket, stats_dims]) for accumulated stats summary (gradient/hessian) per node, per dimension, per buckets for each feature.
+///     The first dimension of the tensor is the maximum number of splits, and thus not all elements of it will be used, but only the indexes specified by node_ids will be used.
+///   - l1: l1 regularization factor on leaf weights, per instance based.
+///   - l2: l2 regularization factor on leaf weights, per instance based.
+///   - tree_complexity: adjustment to the gain, per leaf based.
+///   - min_node_weight: mininum avg of hessians in a node before required for the node to be considered for splitting.
+///
+/// - Attrs:
+///   - logits_dimension: The dimension of logit, i.e., number of classes.
+///   - split_type: A string indicating if this Op should perform inequality split or equality split.
+///
+/// - Outputs:
+///   - node_ids: A Rank 1 tensors indicating possible split node ids for each feature. The length of the list is num_features, but each tensor has different size as each feature provides different possible nodes. See above for details like shapes and sizes.
+///   - gains: A Rank 1 tensors indicating the best gains for each feature to split for certain nodes. See above for details like shapes and sizes.
+///   - feature_dimensions: A Rank 1 tensors indicating the best feature dimension for each feature to split for certain nodes if the feature is multi-dimension. See above for details like shapes and sizes.
+///   - thresholds: A Rank 1 tensors indicating the bucket id to compare with (as a threshold) for split in each node. See above for details like shapes and sizes.
+///   - left_node_contribs: A Rank 2 tensors indicating the contribution of the left nodes when branching from parent nodes (given by the tensor element in the output node_ids_list) to the left direction by the given threshold for each feature. This value will be used to make the left node value by adding to the parent node value. Second dimension size is 1 for 1-dimensional logits, but would be larger for multi-class problems. See above for details like shapes and sizes.
+///   - right_node_contribs: A Rank 2 tensors, with the same shape/conditions as left_node_contribs_list, but just that the value is for the right node.
+///   - split_with_default_directions: A Rank 1 tensors indicating the which direction to go if data is missing. See above for details like shapes and sizes.
+@inlinable @inline(__always)
+public static func boostedTreesCalculateBestFeatureSplit(
+  nodeIdRange: Tensor<Int32>,
+  statsSummary: Tensor<Float>,
+  l1: Tensor<Float>,
+  l2: Tensor<Float>,
+  treeComplexity: Tensor<Float>,
+  minNodeWeight: Tensor<Float>,
+  logitsDimension: Int64,
+  splitType: SplitType = .inequality
+) -> (nodeIds: Tensor<Int32>, gains: Tensor<Float>, featureDimensions: Tensor<Int32>, thresholds: Tensor<Int32>, leftNodeContribs: Tensor<Float>, rightNodeContribs: Tensor<Float>, splitWithDefaultDirections: StringTensor) {
+  let op = TFE_Op("BoostedTreesCalculateBestFeatureSplit")
+  op.setAttr("logits_dimension", logitsDimension)
+  op.setAttr("split_type", splitType.cName)
+  let _ = op.addInput(nodeIdRange)
+  let _ = op.addInput(statsSummary)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  let _ = op.addInput(treeComplexity)
+  let _ = op.addInput(minNodeWeight)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Calculates gains for each feature and returns the best possible split information for the feature.
+///
+/// The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature.
+///
+/// It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split.
+///
+/// In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features).
+///
+/// The length of output lists are all of the same length, `num_features`.
+/// The output shapes are compatible in a way that the first dimension of all tensors of all lists are the same and equal to the number of possible split nodes for each feature.
+///
+/// - Parameters:
+///   - node_id_range: A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive).
+///   - stats_summary_list: A list of Rank 3 tensor (#shape=[max_splits, bucket, 2]) for accumulated stats summary (gradient/hessian) per node per buckets for each feature. The first dimension of the tensor is the maximum number of splits, and thus not all elements of it will be used, but only the indexes specified by node_ids will be used.
+///   - l1: l1 regularization factor on leaf weights, per instance based.
+///   - l2: l2 regularization factor on leaf weights, per instance based.
+///   - tree_complexity: adjustment to the gain, per leaf based.
+///   - min_node_weight: mininum avg of hessians in a node before required for the node to be considered for splitting.
+///
+/// - Attrs:
+///   - max_splits: the number of nodes that can be split in the whole tree. Used as a dimension of output tensors.
+///   - num_features: inferred from the size of `stats_summary_list`; the number of total features.
+///
+/// - Outputs:
+///   - node_ids_list: An output list of Rank 1 tensors indicating possible split node ids for each feature. The length of the list is num_features, but each tensor has different size as each feature provides different possible nodes. See above for details like shapes and sizes.
+///   - gains_list: An output list of Rank 1 tensors indicating the best gains for each feature to split for certain nodes. See above for details like shapes and sizes.
+///   - thresholds_list: An output list of Rank 1 tensors indicating the bucket id to compare with (as a threshold) for split in each node. See above for details like shapes and sizes.
+///   - left_node_contribs_list: A list of Rank 2 tensors indicating the contribution of the left nodes when branching from parent nodes (given by the tensor element in the output node_ids_list) to the left direction by the given threshold for each feature. This value will be used to make the left node value by adding to the parent node value. Second dimension size is 1 for 1-dimensional logits, but would be larger for multi-class problems. See above for details like shapes and sizes.
+///   - right_node_contribs_list: A list of Rank 2 tensors, with the same shape/conditions as left_node_contribs_list, but just that the value is for the right node.
+@inlinable @inline(__always)
+public static func boostedTreesCalculateBestGainsPerFeature(
+  nodeIdRange: Tensor<Int32>,
+  statsSummaryList: [Tensor<Float>],
+  l1: Tensor<Float>,
+  l2: Tensor<Float>,
+  treeComplexity: Tensor<Float>,
+  minNodeWeight: Tensor<Float>,
+  maxSplits: Int64
+) -> (nodeIdsList: [Tensor<Int32>], gainsList: [Tensor<Float>], thresholdsList: [Tensor<Int32>], leftNodeContribsList: [Tensor<Float>], rightNodeContribsList: [Tensor<Float>]) {
+  let op = TFE_Op("BoostedTreesCalculateBestGainsPerFeature")
+  op.setAttr("max_splits", maxSplits)
+  op.setAttr("num_features", statsSummaryList.count)
+  let _ = op.addInput(nodeIdRange)
+  let _ = op.addInputList(statsSummaryList)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  let _ = op.addInput(treeComplexity)
+  let _ = op.addInput(minNodeWeight)
+  return op.execute(Int(statsSummaryList.count), Int(statsSummaryList.count), Int(statsSummaryList.count), Int(statsSummaryList.count), Int(statsSummaryList.count))
+}
+
+/// Calculates the prior from the training data (the bias) and fills in the first node with the logits' prior. Returns a boolean indicating whether to continue centering.
+///
+/// - Parameters:
+///   - tree_ensemble_handle: Handle to the tree ensemble.
+///   - mean_gradients: A tensor with shape=[logits_dimension] with mean of gradients for a first node.
+///   - mean_hessians: A tensor with shape=[logits_dimension] mean of hessians for a first node.
+///   - l1: l1 regularization factor on leaf weights, per instance based.
+///   - l2: l2 regularization factor on leaf weights, per instance based.
+///
+/// - Output continue_centering: Bool, whether to continue bias centering.
+@inlinable @inline(__always)
+public static func boostedTreesCenterBias(
+  treeEnsembleHandle: ResourceHandle,
+  meanGradients: Tensor<Float>,
+  meanHessians: Tensor<Float>,
+  l1: Tensor<Float>,
+  l2: Tensor<Float>
+) -> Tensor<Bool> {
+  let op = TFE_Op("BoostedTreesCenterBias")
+  let _ = op.addInput(treeEnsembleHandle)
+  let _ = op.addInput(meanGradients)
+  let _ = op.addInput(meanHessians)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  return op.execute(Int(1))
+}
+
+/// Creates a tree ensemble model and returns a handle to it.
+///
+/// - Parameters:
+///   - tree_ensemble_handle: Handle to the tree ensemble resource to be created.
+///   - stamp_token: Token to use as the initial value of the resource stamp.
+///   - tree_ensemble_serialized: Serialized proto of the tree ensemble.
+@inlinable @inline(__always)
+public static func boostedTreesCreateEnsemble(
+  treeEnsembleHandle: ResourceHandle,
+  stampToken: Tensor<Int64>,
+  treeEnsembleSerialized: StringTensor
+) {
+  let op = TFE_Op("BoostedTreesCreateEnsemble")
+  let _ = op.addInput(treeEnsembleHandle)
+  let _ = op.addInput(stampToken)
+  let _ = op.addInput(treeEnsembleSerialized)
+  op.execute()
+}
+
+/// Create the Resource for Quantile Streams.
+///
+/// - Parameters:
+///   - quantile_stream_resource_handle: resource; Handle to quantile stream resource.
+///   - epsilon: float; The required approximation error of the stream resource.
+///   - num_streams: int; The number of streams managed by the resource that shares the same epsilon.
+///
+/// - Attr max_elements: int; The maximum number of data points that can be fed to the stream.
+@inlinable @inline(__always)
+public static func boostedTreesCreateQuantileStreamResource(
+  quantileStreamResourceHandle: ResourceHandle,
+  epsilon: Tensor<Float>,
+  numStreams: Tensor<Int64>,
+  maxElements: Int64 = 1099511627776
+) {
+  let op = TFE_Op("BoostedTreesCreateQuantileStreamResource")
+  op.setAttr("max_elements", maxElements)
+  let _ = op.addInput(quantileStreamResourceHandle)
+  let _ = op.addInput(epsilon)
+  let _ = op.addInput(numStreams)
+  op.execute()
+}
+
+/// Deserializes a serialized tree ensemble config and replaces current tree
+///
+/// ensemble.
+///
+/// - Parameters:
+///   - tree_ensemble_handle: Handle to the tree ensemble.
+///   - stamp_token: Token to use as the new value of the resource stamp.
+///   - tree_ensemble_serialized: Serialized proto of the ensemble.
+@inlinable @inline(__always)
+public static func boostedTreesDeserializeEnsemble(
+  treeEnsembleHandle: ResourceHandle,
+  stampToken: Tensor<Int64>,
+  treeEnsembleSerialized: StringTensor
+) {
+  let op = TFE_Op("BoostedTreesDeserializeEnsemble")
+  let _ = op.addInput(treeEnsembleHandle)
+  let _ = op.addInput(stampToken)
+  let _ = op.addInput(treeEnsembleSerialized)
+  op.execute()
+}
+
+/// Creates a handle to a BoostedTreesEnsembleResource
+@inlinable @inline(__always)
+public static func boostedTreesEnsembleResourceHandleOp(
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("BoostedTreesEnsembleResourceHandleOp")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Debugging/model interpretability outputs for each example.
+///
+/// It traverses all the trees and computes debug metrics for individual examples, 
+/// such as getting split feature ids and logits after each split along the decision
+/// path used to compute directional feature contributions.
+///
+/// - Parameter bucketized_features: A list of rank 1 Tensors containing bucket id for each
+///   feature.
+///
+/// - Attrs:
+///   - num_bucketized_features: Inferred.
+///   - logits_dimension: scalar, dimension of the logits, to be used for constructing the protos in
+///     examples_debug_outputs_serialized.
+///
+/// - Output examples_debug_outputs_serialized: Output rank 1 Tensor containing a proto serialized as a string for each example.
+@inlinable @inline(__always)
+public static func boostedTreesExampleDebugOutputs(
+  treeEnsembleHandle: ResourceHandle,
+  bucketizedFeatures: [Tensor<Int32>],
+  logitsDimension: Int64
+) -> StringTensor {
+  let op = TFE_Op("BoostedTreesExampleDebugOutputs")
+  op.setAttr("num_bucketized_features", bucketizedFeatures.count)
+  op.setAttr("logits_dimension", logitsDimension)
+  let _ = op.addInput(treeEnsembleHandle)
+  let _ = op.addInputList(bucketizedFeatures)
+  return op.execute(Int(1))
+}
+
+/// Retrieves the tree ensemble resource stamp token, number of trees and growing statistics.
+///
+/// - Parameter tree_ensemble_handle: Handle to the tree ensemble.
+///
+/// - Outputs:
+///   - stamp_token: Stamp token of the tree ensemble resource.
+///   - num_trees: The number of trees in the tree ensemble resource.
+///   - num_finalized_trees: The number of trees that were finished successfully.
+///   - num_attempted_layers: The number of layers we attempted to build (but not necessarily succeeded).
+///   - last_layer_nodes_range: Rank size 2 tensor that contains start and end ids of the nodes in the latest
+///     layer.
+@inlinable @inline(__always)
+public static func boostedTreesGetEnsembleStates(
+  treeEnsembleHandle: ResourceHandle
+) -> (stampToken: Tensor<Int64>, numTrees: Tensor<Int32>, numFinalizedTrees: Tensor<Int32>, numAttemptedLayers: Tensor<Int32>, lastLayerNodesRange: Tensor<Int32>) {
+  let op = TFE_Op("BoostedTreesGetEnsembleStates")
+  let _ = op.addInput(treeEnsembleHandle)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Makes the summary of quantiles for the batch.
+///
+/// An op that takes a list of tensors (one tensor per feature) and outputs the
+/// quantile summaries for each tensor.
+///
+/// - Parameters:
+///   - float_values: float; List of Rank 1 Tensors each containing values for a single feature.
+///   - example_weights: float; Rank 1 Tensor with weights per instance.
+///   - epsilon: float; The required maximum approximation error.
+///
+/// - Attr num_features: int; Inferred from the size of float_values.
+///   The number of float features.
+///
+/// - Output summaries: float; List of Rank 2 Tensors each containing the quantile summary
+///   (value, weight, min_rank, max_rank) of a single feature.
+@inlinable @inline(__always)
+public static func boostedTreesMakeQuantileSummaries(
+  floatValues: [Tensor<Float>],
+  exampleWeights: Tensor<Float>,
+  epsilon: Tensor<Float>
+) -> [Tensor<Float>] {
+  let op = TFE_Op("BoostedTreesMakeQuantileSummaries")
+  op.setAttr("num_features", floatValues.count)
+  let _ = op.addInputList(floatValues)
+  let _ = op.addInput(exampleWeights)
+  let _ = op.addInput(epsilon)
+  return op.execute(Int(floatValues.count))
+}
+
+/// Makes the summary of accumulated stats for the batch.
+///
+/// The summary stats contains gradients and hessians accumulated into the corresponding node and bucket for each example.
+///
+/// - Parameters:
+///   - node_ids: int32 Rank 1 Tensor containing node ids, which each example falls into for the requested layer.
+///   - gradients: float32; Rank 2 Tensor (shape=[#examples, 1]) for gradients.
+///   - hessians: float32; Rank 2 Tensor (shape=[#examples, 1]) for hessians.
+///   - bucketized_features_list: int32 list of Rank 1 Tensors, each containing the bucketized feature (for each feature column).
+///
+/// - Attrs:
+///   - max_splits: int; the maximum number of splits possible in the whole tree.
+///   - num_buckets: int; equals to the maximum possible value of bucketized feature.
+///   - num_features: int; inferred from the size of bucketized_features_list; the number of features.
+///
+/// - Output stats_summary: output Rank 4 Tensor (shape=[#features, #splits, #buckets, 2]) containing accumulated stats put into the corresponding node and bucket. The first index of 4th dimension refers to gradients, and the second to hessians.
+@inlinable @inline(__always)
+public static func boostedTreesMakeStatsSummary(
+  nodeIds: Tensor<Int32>,
+  gradients: Tensor<Float>,
+  hessians: Tensor<Float>,
+  bucketizedFeaturesList: [Tensor<Int32>],
+  maxSplits: Int64,
+  numBuckets: Int64
+) -> Tensor<Float> {
+  let op = TFE_Op("BoostedTreesMakeStatsSummary")
+  op.setAttr("max_splits", maxSplits)
+  op.setAttr("num_buckets", numBuckets)
+  op.setAttr("num_features", bucketizedFeaturesList.count)
+  let _ = op.addInput(nodeIds)
+  let _ = op.addInput(gradients)
+  let _ = op.addInput(hessians)
+  let _ = op.addInputList(bucketizedFeaturesList)
+  return op.execute(Int(1))
+}
+
+/// Runs multiple additive regression ensemble predictors on input instances and
+///
+/// computes the logits. It is designed to be used during prediction.
+/// It traverses all the trees and calculates the final score for each instance.
+///
+/// - Parameter bucketized_features: A list of rank 1 Tensors containing bucket id for each
+///   feature.
+///
+/// - Attrs:
+///   - num_bucketized_features: Inferred.
+///   - logits_dimension: scalar, dimension of the logits, to be used for partial logits
+///     shape.
+///
+/// - Output logits: Output rank 2 Tensor containing logits for each example.
+@inlinable @inline(__always)
+public static func boostedTreesPredict(
+  treeEnsembleHandle: ResourceHandle,
+  bucketizedFeatures: [Tensor<Int32>],
+  logitsDimension: Int64
+) -> Tensor<Float> {
+  let op = TFE_Op("BoostedTreesPredict")
+  op.setAttr("num_bucketized_features", bucketizedFeatures.count)
+  op.setAttr("logits_dimension", logitsDimension)
+  let _ = op.addInput(treeEnsembleHandle)
+  let _ = op.addInputList(bucketizedFeatures)
+  return op.execute(Int(1))
+}
+
+/// Add the quantile summaries to each quantile stream resource.
+///
+/// An op that adds a list of quantile summaries to a quantile stream resource. Each
+/// summary Tensor is rank 2, containing summaries (value, weight, min_rank, max_rank)
+/// for a single feature.
+///
+/// - Parameters:
+///   - quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
+///   - summaries: string; List of Rank 2 Tensor each containing the summaries for a single feature.
+@inlinable @inline(__always)
+public static func boostedTreesQuantileStreamResourceAddSummaries(
+  quantileStreamResourceHandle: ResourceHandle,
+  summaries: [Tensor<Float>]
+) {
+  let op = TFE_Op("BoostedTreesQuantileStreamResourceAddSummaries")
+  op.setAttr("num_features", summaries.count)
+  let _ = op.addInput(quantileStreamResourceHandle)
+  let _ = op.addInputList(summaries)
+  op.execute()
+}
+
+/// Deserialize bucket boundaries and ready flag into current QuantileAccumulator.
+///
+/// An op that deserializes bucket boundaries and are boundaries ready flag into current QuantileAccumulator.
+///
+/// - Parameters:
+///   - quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
+///   - bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a feature.
+///
+/// - Attr num_streams: inferred int; number of features to get bucket boundaries for.
+@inlinable @inline(__always)
+public static func boostedTreesQuantileStreamResourceDeserialize(
+  quantileStreamResourceHandle: ResourceHandle,
+  bucketBoundaries: [Tensor<Float>]
+) {
+  let op = TFE_Op("BoostedTreesQuantileStreamResourceDeserialize")
+  op.setAttr("num_streams", bucketBoundaries.count)
+  let _ = op.addInput(quantileStreamResourceHandle)
+  let _ = op.addInputList(bucketBoundaries)
+  op.execute()
+}
+
+/// Flush the summaries for a quantile stream resource.
+///
+/// An op that flushes the summaries for a quantile stream resource.
+///
+/// - Parameters:
+///   - quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
+///   - num_buckets: int; approximate number of buckets unless using generate_quantiles.
+///
+/// - Attr generate_quantiles: bool; If True, the output will be the num_quantiles for each stream where the ith
+///   entry is the ith quantile of the input with an approximation error of epsilon.
+///   Duplicate values may be present.
+///   If False, the output will be the points in the histogram that we got which roughly
+///   translates to 1/epsilon boundaries and without any duplicates.
+///   Default to False.
+@inlinable @inline(__always)
+public static func boostedTreesQuantileStreamResourceFlush(
+  quantileStreamResourceHandle: ResourceHandle,
+  numBuckets: Tensor<Int64>,
+  generateQuantiles: Bool = false
+) {
+  let op = TFE_Op("BoostedTreesQuantileStreamResourceFlush")
+  op.setAttr("generate_quantiles", generateQuantiles)
+  let _ = op.addInput(quantileStreamResourceHandle)
+  let _ = op.addInput(numBuckets)
+  op.execute()
+}
+
+/// Generate the bucket boundaries for each feature based on accumulated summaries.
+///
+/// An op that returns a list of float tensors for a quantile stream resource. Each
+/// tensor is Rank 1 containing bucket boundaries for a single feature.
+///
+/// - Parameter quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
+///
+/// - Attr num_features: inferred int; number of features to get bucket boundaries for.
+///
+/// - Output bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a feature.
+@inlinable @inline(__always)
+public static func boostedTreesQuantileStreamResourceGetBucketBoundaries(
+  quantileStreamResourceHandle: ResourceHandle,
+  numFeatures: Int64
+) -> [Tensor<Float>] {
+  let op = TFE_Op("BoostedTreesQuantileStreamResourceGetBucketBoundaries")
+  op.setAttr("num_features", numFeatures)
+  let _ = op.addInput(quantileStreamResourceHandle)
+  return op.execute(Int(numFeatures))
+}
+
+/// Creates a handle to a BoostedTreesQuantileStreamResource.
+@inlinable @inline(__always)
+public static func boostedTreesQuantileStreamResourceHandleOp(
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("BoostedTreesQuantileStreamResourceHandleOp")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Serializes the tree ensemble to a proto.
+///
+/// - Parameter tree_ensemble_handle: Handle to the tree ensemble.
+///
+/// - Outputs:
+///   - stamp_token: Stamp token of the tree ensemble resource.
+///   - tree_ensemble_serialized: Serialized proto of the ensemble.
+@inlinable @inline(__always)
+public static func boostedTreesSerializeEnsemble(
+  treeEnsembleHandle: ResourceHandle
+) -> (stampToken: Tensor<Int64>, treeEnsembleSerialized: StringTensor) {
+  let op = TFE_Op("BoostedTreesSerializeEnsemble")
+  let _ = op.addInput(treeEnsembleHandle)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Runs multiple additive regression ensemble predictors on input instances and
+///
+/// computes the update to cached logits. It is designed to be used during training.
+/// It traverses the trees starting from cached tree id and cached node id and
+/// calculates the updates to be pushed to the cache.
+///
+/// - Parameters:
+///   - cached_tree_ids: Rank 1 Tensor containing cached tree ids which is the starting
+///     tree of prediction.
+///   - cached_node_ids: Rank 1 Tensor containing cached node id which is the starting
+///     node of prediction.
+///   - bucketized_features: A list of rank 1 Tensors containing bucket id for each
+///     feature.
+///
+/// - Attrs:
+///   - num_bucketized_features: Inferred.
+///   - logits_dimension: scalar, dimension of the logits, to be used for partial logits
+///     shape.
+///
+/// - Outputs:
+///   - partial_logits: Rank 2 Tensor containing logits update (with respect to cached
+///     values stored) for each example.
+///   - tree_ids: Rank 1 Tensor containing new tree ids for each example.
+///   - node_ids: Rank 1 Tensor containing new node ids in the new tree_ids.
+@inlinable @inline(__always)
+public static func boostedTreesTrainingPredict(
+  treeEnsembleHandle: ResourceHandle,
+  cachedTreeIds: Tensor<Int32>,
+  cachedNodeIds: Tensor<Int32>,
+  bucketizedFeatures: [Tensor<Int32>],
+  logitsDimension: Int64
+) -> (partialLogits: Tensor<Float>, treeIds: Tensor<Int32>, nodeIds: Tensor<Int32>) {
+  let op = TFE_Op("BoostedTreesTrainingPredict")
+  op.setAttr("num_bucketized_features", bucketizedFeatures.count)
+  op.setAttr("logits_dimension", logitsDimension)
+  let _ = op.addInput(treeEnsembleHandle)
+  let _ = op.addInput(cachedTreeIds)
+  let _ = op.addInput(cachedNodeIds)
+  let _ = op.addInputList(bucketizedFeatures)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Updates the tree ensemble by either adding a layer to the last tree being grown
+///
+/// or by starting a new tree.
+///
+/// - Parameters:
+///   - tree_ensemble_handle: Handle to the ensemble variable.
+///   - feature_ids: Rank 1 tensor with ids for each feature. This is the real id of
+///     the feature that will be used in the split.
+///   - node_ids: List of rank 1 tensors representing the nodes for which this feature
+///     has a split.
+///   - gains: List of rank 1 tensors representing the gains for each of the feature's
+///     split.
+///   - thresholds: List of rank 1 tensors representing the thesholds for each of the
+///     feature's split.
+///   - left_node_contribs: List of rank 2 tensors with left leaf contribs for each of
+///     the feature's splits. Will be added to the previous node values to constitute
+///     the values of the left nodes.
+///   - right_node_contribs: List of rank 2 tensors with right leaf contribs for each
+///     of the feature's splits. Will be added to the previous node values to constitute
+///     the values of the right nodes.
+///   - max_depth: Max depth of the tree to build.
+///   - learning_rate: shrinkage const for each new tree.
+///
+/// - Attrs:
+///   - pruning_mode: 0-No pruning, 1-Pre-pruning, 2-Post-pruning.
+///   - num_features: Number of features that have best splits returned. INFERRED.
+@inlinable @inline(__always)
+public static func boostedTreesUpdateEnsemble(
+  treeEnsembleHandle: ResourceHandle,
+  featureIds: Tensor<Int32>,
+  nodeIds: [Tensor<Int32>],
+  gains: [Tensor<Float>],
+  thresholds: [Tensor<Int32>],
+  leftNodeContribs: [Tensor<Float>],
+  rightNodeContribs: [Tensor<Float>],
+  maxDepth: Tensor<Int32>,
+  learningRate: Tensor<Float>,
+  pruningMode: Int64
+) {
+  let op = TFE_Op("BoostedTreesUpdateEnsemble")
+  op.setAttr("pruning_mode", pruningMode)
+  op.setAttr("num_features", nodeIds.count)
+  let _ = op.addInput(treeEnsembleHandle)
+  let _ = op.addInput(featureIds)
+  let _ = op.addInputList(nodeIds)
+  let _ = op.addInputList(gains)
+  let _ = op.addInputList(thresholds)
+  let _ = op.addInputList(leftNodeContribs)
+  let _ = op.addInputList(rightNodeContribs)
+  let _ = op.addInput(maxDepth)
+  let _ = op.addInput(learningRate)
+  op.execute()
+}
+
+/// Return the shape of s0 op s1 with broadcast.
+///
+/// Given `s0` and `s1`, tensors that represent shapes, compute `r0`, the
+/// broadcasted shape. `s0`, `s1` and `r0` are all integer vectors.
+@inlinable @inline(__always)
+public static func broadcastArgs<T: BinaryInteger & TensorFlowScalar>(
+  s0: Tensor<T>,
+  s1: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("BroadcastArgs")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(s0)
+  let _ = op.addInput(s1)
+  return op.execute(Int(1))
+}
+
+/// Return the reduction indices for computing gradients of s0 op s1 with broadcast.
+///
+/// This is typically used by gradient computations for a broadcasting operation.
+@inlinable @inline(__always)
+public static func broadcastGradientArgs<T: BinaryInteger & TensorFlowScalar>(
+  s0: Tensor<T>,
+  s1: Tensor<T>
+) -> (r0: Tensor<T>, r1: Tensor<T>) {
+  let op = TFE_Op("BroadcastGradientArgs")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(s0)
+  let _ = op.addInput(s1)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Broadcast an array for a compatible shape.
+///
+/// Broadcasting is the process of making arrays to have compatible shapes
+/// for arithmetic operations. Two shapes are compatible if for each
+/// dimension pair they are either equal or one of them is one. When trying
+/// to broadcast a Tensor to a shape, it starts with the trailing dimensions,
+/// and works its way forward.
+///
+/// For example,
+/// ```
+/// >>> x = tf.constant([1, 2, 3])
+/// >>> y = tf.broadcast_to(x, [3, 3])
+/// >>> sess.run(y)
+/// array([[1, 2, 3],
+///        [1, 2, 3],
+///        [1, 2, 3]], dtype=int32)
+/// ```
+/// In the above example, the input Tensor with the shape of `[1, 3]`
+/// is broadcasted to output Tensor with shape of `[3, 3]`.
+///
+/// - Parameters:
+///   - input: A Tensor to broadcast.
+///   - shape: An 1-D `int` Tensor. The shape of the desired output.
+///
+/// - Output output: A Tensor.
+@inlinable @inline(__always)
+public static func broadcastTo<
+    T: TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  shape: Tensor<Tidx>
+) -> Tensor<T> {
+  let op = TFE_Op("BroadcastTo")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Bucketizes 'input' based on 'boundaries'.
+///
+/// For example, if the inputs are
+///     boundaries = [0, 10, 100]
+///     input = [[-5, 10000]
+///              [150,   10]
+///              [5,    100]]
+///
+/// then the output will be
+///     output = [[0, 3]
+///               [3, 2]
+///               [1, 3]]
+///
+/// - Parameter input: Any shape of Tensor contains with int or float type.
+///
+/// - Attr boundaries: A sorted list of floats gives the boundary of the buckets.
+///
+/// - Output output: Same shape with 'input', each value of input replaced with bucket index.
+///
+///   @compatibility(numpy)
+///   Equivalent to np.digitize.
+///   @end_compatibility
+@inlinable @inline(__always)
+public static func bucketize<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  boundaries: [Double]
+) -> Tensor<Int32> {
+  let op = TFE_Op("Bucketize")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("boundaries", boundaries)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Performs beam search decoding on the logits given in input.
+///
+/// A note about the attribute merge_repeated: For the beam search decoder,
+/// this means that if consecutive entries in a beam are the same, only
+/// the first of these is emitted.  That is, when the top path is "A B B B B",
+/// "A B" is returned if merge_repeated = True but "A B B B B" is
+/// returned if merge_repeated = False.
+///
+/// - Parameters:
+///   - inputs: 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
+///   - sequence_length: A vector containing sequence lengths, size `(batch)`.
+///
+/// - Attrs:
+///   - beam_width: A scalar >= 0 (beam search beam width).
+///   - top_paths: A scalar >= 0, <= beam_width (controls output size).
+///   - merge_repeated: If true, merge repeated classes in output.
+///
+/// - Outputs:
+///   - decoded_indices: A list (length: top_paths) of indices matrices.  Matrix j,
+///     size `(total_decoded_outputs[j] x 2)`, has indices of a
+///     `SparseTensor<int64, 2>`.  The rows store: [batch, time].
+///   - decoded_values: A list (length: top_paths) of values vectors.  Vector j,
+///     size `(length total_decoded_outputs[j])`, has the values of a
+///     `SparseTensor<int64, 2>`.  The vector stores the decoded classes for beam j.
+///   - decoded_shape: A list (length: top_paths) of shape vector.  Vector j,
+///     size `(2)`, stores the shape of the decoded `SparseTensor[j]`.
+///     Its values are: `[batch_size, max_decoded_length[j]]`.
+///   - log_probability: A matrix, shaped: `(batch_size x top_paths)`.  The
+///     sequence log-probabilities.
+@inlinable @inline(__always)
+public static func cTCBeamSearchDecoder(
+  inputs: Tensor<Float>,
+  sequenceLength: Tensor<Int32>,
+  beamWidth: Int64,
+  topPaths: Int64,
+  mergeRepeated: Bool = true
+) -> (decodedIndices: [Tensor<Int64>], decodedValues: [Tensor<Int64>], decodedShape: [Tensor<Int64>], logProbability: Tensor<Float>) {
+  let op = TFE_Op("CTCBeamSearchDecoder")
+  op.setAttr("beam_width", beamWidth)
+  op.setAttr("top_paths", topPaths)
+  op.setAttr("merge_repeated", mergeRepeated)
+  let _ = op.addInput(inputs)
+  let _ = op.addInput(sequenceLength)
+  return op.execute(Int(topPaths), Int(topPaths), Int(topPaths), Int(1))
+}
+
+/// Performs greedy decoding on the logits given in inputs.
+///
+/// A note about the attribute merge_repeated: if enabled, when
+/// consecutive logits' maximum indices are the same, only the first of
+/// these is emitted.  Labeling the blank '*', the sequence "A B B * B B"
+/// becomes "A B B" if merge_repeated = True and "A B B B B" if
+/// merge_repeated = False.
+///
+/// Regardless of the value of merge_repeated, if the maximum index of a given
+/// time and batch corresponds to the blank, index `(num_classes - 1)`, no new
+/// element is emitted.
+///
+/// - Parameters:
+///   - inputs: 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
+///   - sequence_length: A vector containing sequence lengths, size `(batch_size)`.
+///
+/// - Attr merge_repeated: If True, merge repeated classes in output.
+///
+/// - Outputs:
+///   - decoded_indices: Indices matrix, size `(total_decoded_outputs x 2)`,
+///     of a `SparseTensor<int64, 2>`.  The rows store: [batch, time].
+///   - decoded_values: Values vector, size: `(total_decoded_outputs)`,
+///     of a `SparseTensor<int64, 2>`.  The vector stores the decoded classes.
+///   - decoded_shape: Shape vector, size `(2)`, of the decoded SparseTensor.
+///     Values are: `[batch_size, max_decoded_length]`.
+///   - log_probability: Matrix, size `(batch_size x 1)`, containing sequence
+///     log-probabilities.
+@inlinable @inline(__always)
+public static func cTCGreedyDecoder(
+  inputs: Tensor<Float>,
+  sequenceLength: Tensor<Int32>,
+  mergeRepeated: Bool = false
+) -> (decodedIndices: Tensor<Int64>, decodedValues: Tensor<Int64>, decodedShape: Tensor<Int64>, logProbability: Tensor<Float>) {
+  let op = TFE_Op("CTCGreedyDecoder")
+  op.setAttr("merge_repeated", mergeRepeated)
+  let _ = op.addInput(inputs)
+  let _ = op.addInput(sequenceLength)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Calculates the CTC Loss (log probability) for each batch entry.  Also calculates
+///
+/// the gradient.  This class performs the softmax operation for you, so inputs
+/// should be e.g. linear projections of outputs by an LSTM.
+///
+/// - Parameters:
+///   - inputs: 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
+///   - labels_indices: The indices of a `SparseTensor<int32, 2>`.
+///     `labels_indices(i, :) == [b, t]` means `labels_values(i)` stores the id for
+///     `(batch b, time t)`.
+///   - labels_values: The values (labels) associated with the given batch and time.
+///   - sequence_length: A vector containing sequence lengths (batch).
+///
+/// - Attrs:
+///   - preprocess_collapse_repeated: Scalar, if true then repeated labels are
+///     collapsed prior to the CTC calculation.
+///   - ctc_merge_repeated: Scalar.  If set to false, *during* CTC calculation
+///     repeated non-blank labels will not be merged and are interpreted as
+///     individual labels.  This is a simplified version of CTC.
+///   - ignore_longer_outputs_than_inputs: Scalar. If set to true, during CTC
+///     calculation, items that have longer output sequences than input sequences
+///     are skipped: they don't contribute to the loss term and have zero-gradient.
+///
+/// - Outputs:
+///   - loss: A vector (batch) containing log-probabilities.
+///   - gradient: The gradient of `loss`.  3-D, shape:
+///     `(max_time x batch_size x num_classes)`.
+@inlinable @inline(__always)
+public static func cTCLoss(
+  inputs: Tensor<Float>,
+  labelsIndices: Tensor<Int64>,
+  labelsValues: Tensor<Int32>,
+  sequenceLength: Tensor<Int32>,
+  preprocessCollapseRepeated: Bool = false,
+  ctcMergeRepeated: Bool = true,
+  ignoreLongerOutputsThanInputs: Bool = false
+) -> (loss: Tensor<Float>, gradient: Tensor<Float>) {
+  let op = TFE_Op("CTCLoss")
+  op.setAttr("preprocess_collapse_repeated", preprocessCollapseRepeated)
+  op.setAttr("ctc_merge_repeated", ctcMergeRepeated)
+  op.setAttr("ignore_longer_outputs_than_inputs", ignoreLongerOutputsThanInputs)
+  let _ = op.addInput(inputs)
+  let _ = op.addInput(labelsIndices)
+  let _ = op.addInput(labelsValues)
+  let _ = op.addInput(sequenceLength)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Creates a dataset that caches elements from `input_dataset`.
+///
+/// A CacheDataset will iterate over the input_dataset, and store tensors. If the
+/// cache already exists, the cache will be used. If the cache is inappropriate
+/// (e.g. cannot be opened, contains tensors of the wrong shape / size), an error
+/// will the returned when used.
+///
+/// - Parameter filename: A path on the filesystem where we should cache the dataset. Note: this
+///   will be a directory.
+@inlinable @inline(__always)
+public static func cacheDataset(
+  inputDataset: VariantHandle,
+  filename: StringTensor,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("CacheDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(filename)
+  return op.execute(Int(1))
+}
+
+/// Cast x of type SrcT to y of DstT.
+@inlinable @inline(__always)
+public static func cast<
+    Srct: TensorFlowScalar,
+    Dstt: TensorFlowScalar
+>(
+  _ x: Tensor<Srct>,
+  truncate: Bool = false
+) -> Tensor<Dstt> {
+  let op = TFE_Op("Cast")
+  op.setAttr("SrcT", Srct.tensorFlowDataType)
+  op.setAttr("DstT", Dstt.tensorFlowDataType)
+  op.setAttr("Truncate", truncate)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns element-wise smallest integer not less than x.
+@inlinable @inline(__always)
+public static func ceil<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Ceil")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// 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.
+///
+/// - Attr message: Prefix of the error message.
+@inlinable @inline(__always)
+public static func checkNumerics<T: FloatingPoint & TensorFlowScalar>(
+  _ tensor: Tensor<T>,
+  message: String
+) -> Tensor<T> {
+  let op = TFE_Op("CheckNumerics")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("message", message)
+  let _ = op.addInput(tensor)
+  return op.execute(Int(1))
+}
+
+/// Computes the Cholesky decomposition of one or more square matrices.
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices.
+///
+/// The input has to be symmetric and positive definite. Only the lower-triangular
+/// part of the input will be used for this operation. The upper-triangular part
+/// will not be read.
+///
+/// The output is a tensor of the same shape as the input
+/// containing the Cholesky decompositions for all input submatrices `[..., :, :]`.
+///
+/// **Note**: The gradient computation on GPU is faster for large matrices but
+/// not for large batch dimensions when the submatrices are small. In this
+/// case it might be faster to use the CPU.
+///
+/// - Parameter input: Shape is `[..., M, M]`.
+///
+/// - Output output: Shape is `[..., M, M]`.
+@inlinable @inline(__always)
+public static func cholesky<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Cholesky")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Computes the reverse mode backpropagated gradient of the Cholesky algorithm.
+///
+/// For an explanation see "Differentiation of the Cholesky algorithm" by
+/// Iain Murray http://arxiv.org/abs/1602.07527.
+///
+/// - Parameters:
+///   - l: Output of batch Cholesky algorithm l = cholesky(A). Shape is `[..., M, M]`.
+///     Algorithm depends only on lower triangular part of the innermost matrices of
+///     this tensor.
+///   - grad: df/dl where f is some scalar function. Shape is `[..., M, M]`.
+///     Algorithm depends only on lower triangular part of the innermost matrices of
+///     this tensor.
+///
+/// - Output output: Symmetrized version of df/dA . Shape is `[..., M, M]`
+@inlinable @inline(__always)
+public static func choleskyGrad<T: FloatingPoint & TensorFlowScalar>(
+  l: Tensor<T>,
+  grad: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("CholeskyGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(l)
+  let _ = op.addInput(grad)
+  return op.execute(Int(1))
+}
+
+/// Clips tensor values to a specified min and max.
+///
+/// Given a tensor `t`, this operation returns a tensor of the same type and
+/// shape as `t` with its values clipped to `clip_value_min` and `clip_value_max`.
+/// Any values less than `clip_value_min` are set to `clip_value_min`. Any values
+/// greater than `clip_value_max` are set to `clip_value_max`.
+///
+/// - Parameters:
+///   - t: A `Tensor`.
+///   - clip_value_min: A 0-D (scalar) `Tensor`, or a `Tensor` with the same shape
+///     as `t`. The minimum value to clip by.
+///   - clip_value_max: A 0-D (scalar) `Tensor`, or a `Tensor` with the same shape
+///     as `t`. The maximum value to clip by.
+///
+/// - Output output: A clipped `Tensor` with the same shape as input 't'.
+@inlinable @inline(__always)
+public static func clipByValue<T: Numeric & TensorFlowScalar>(
+  t: Tensor<T>,
+  clipValueMin: Tensor<T>,
+  clipValueMax: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("ClipByValue")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(t)
+  let _ = op.addInput(clipValueMin)
+  let _ = op.addInput(clipValueMax)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func closeSummaryWriter(
+  writer: ResourceHandle
+) {
+  let op = TFE_Op("CloseSummaryWriter")
+  let _ = op.addInput(writer)
+  op.execute()
+}
+
+/// Receives a tensor value broadcast from another device.
+@inlinable @inline(__always)
+public static func collectiveBcastRecv<T: Numeric & TensorFlowScalar>(
+  groupSize: Int64,
+  groupKey: Int64,
+  instanceKey: Int64,
+  shape: TensorShape?
+) -> Tensor<T> {
+  let op = TFE_Op("CollectiveBcastRecv")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("group_size", groupSize)
+  op.setAttr("group_key", groupKey)
+  op.setAttr("instance_key", instanceKey)
+  op.setAttr("shape", shape)
+  return op.execute(Int(1))
+}
+
+/// Broadcasts a tensor value to one or more other devices.
+@inlinable @inline(__always)
+public static func collectiveBcastSend<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  groupSize: Int64,
+  groupKey: Int64,
+  instanceKey: Int64,
+  shape: TensorShape?
+) -> Tensor<T> {
+  let op = TFE_Op("CollectiveBcastSend")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("group_size", groupSize)
+  op.setAttr("group_key", groupKey)
+  op.setAttr("instance_key", instanceKey)
+  op.setAttr("shape", shape)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Mutually accumulates multiple tensors of identical type and shape.
+@inlinable @inline(__always)
+public static func collectiveGather<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  groupSize: Int64,
+  groupKey: Int64,
+  instanceKey: Int64,
+  shape: TensorShape?
+) -> Tensor<T> {
+  let op = TFE_Op("CollectiveGather")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("group_size", groupSize)
+  op.setAttr("group_key", groupKey)
+  op.setAttr("instance_key", instanceKey)
+  op.setAttr("shape", shape)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// An Op to permute tensors across replicated TPU instances.
+///
+/// Each instance supplies its own input.
+///
+/// For example, suppose there are 4 TPU instances: `[A, B, C, D]`. Passing
+/// source_target_pairs=`[[0,1],[1,2],[2,3],[3,0]]` gets the outputs:
+/// `[D, A, B, C]`.
+///
+/// - Parameters:
+///   - input: The local input to be permuted. Currently only supports float and
+///     bfloat16.
+///   - source_target_pairs: A tensor with shape [num_pairs, 2].
+///
+/// - Attr T: The type of elements to be exchanged.
+///
+/// - Output output: The permuted input.
+@inlinable @inline(__always)
+public static func collectivePermute<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  sourceTargetPairs: Tensor<Int32>
+) -> Tensor<T> {
+  let op = TFE_Op("CollectivePermute")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(sourceTargetPairs)
+  return op.execute(Int(1))
+}
+
+/// Mutually reduces multiple tensors of identical type and shape.
+@inlinable @inline(__always)
+public static func collectiveReduce<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  groupSize: Int64,
+  groupKey: Int64,
+  instanceKey: Int64,
+  mergeOp: MergeOp,
+  finalOp: FinalOp,
+  subdivOffsets: [Int32],
+  waitFor: [Int32]
+) -> Tensor<T> {
+  let op = TFE_Op("CollectiveReduce")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("group_size", groupSize)
+  op.setAttr("group_key", groupKey)
+  op.setAttr("instance_key", instanceKey)
+  op.setAttr("merge_op", mergeOp.cName)
+  op.setAttr("final_op", finalOp.cName)
+  op.setAttr("subdiv_offsets", subdivOffsets)
+  op.setAttr("wait_for", waitFor)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Greedily selects a subset of bounding boxes in descending order of score,
+///
+/// This operation performs non_max_suppression on the inputs per batch, across
+/// all classes.
+/// Prunes away boxes that have high intersection-over-union (IOU) overlap
+/// with previously selected boxes.  Bounding boxes are supplied as
+/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+/// diagonal pair of box corners and the coordinates can be provided as normalized
+/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+/// is agnostic to where the origin is in the coordinate system. Also note that
+/// this algorithm is invariant to orthogonal transformations and translations
+/// of the coordinate system; thus translating or reflections of the coordinate
+/// system result in the same boxes being selected by the algorithm.
+/// The output of this operation is the final boxes, scores and classes tensor
+/// returned after performing non_max_suppression.
+///
+/// - Parameters:
+///   - boxes: A 4-D float tensor of shape `[batch_size, num_boxes, q, 4]`. If `q` is 1 then 
+///     same boxes are used for all classes otherwise, if `q` is equal to number of 
+///     classes, class-specific boxes are used.
+///   - scores: A 3-D float tensor of shape `[batch_size, num_boxes, num_classes]`
+///     representing a single score corresponding to each box (each row of boxes).
+///   - max_output_size_per_class: A scalar integer tensor representing the maximum number of 
+///     boxes to be selected by non max suppression per class
+///   - max_total_size: A scalar representing maximum number of boxes retained over all classes.
+///   - iou_threshold: A 0-D float tensor representing the threshold for deciding whether
+///     boxes overlap too much with respect to IOU.
+///   - score_threshold: A 0-D float tensor representing the threshold for deciding when to remove
+///     boxes based on score.
+///
+/// - Attrs:
+///   - pad_per_class: If false, the output nmsed boxes, scores and classes
+///     are padded/clipped to `max_total_size`. If true, the
+///     output nmsed boxes, scores and classes are padded to be of length
+///     `max_size_per_class`*`num_classes`, unless it exceeds `max_total_size` in
+///     which case it is clipped to `max_total_size`. Defaults to false.
+///   - clip_boxes: If true, assume the box coordinates are between [0, 1] and clip the output boxes
+///     if they fall beyond [0, 1]. If false, do not do clipping and output the box
+///     coordinates as it is.
+///
+/// - Outputs:
+///   - nmsed_boxes: A [batch_size, max_detections, 4] float32 tensor 
+///     containing the non-max suppressed boxes.
+///   - nmsed_scores: A [batch_size, max_detections] float32 tensor 
+///     containing the scores for the boxes.
+///   - nmsed_classes: A [batch_size, max_detections] float32 tensor 
+///     containing the classes for the boxes.
+///   - valid_detections: A [batch_size] int32 tensor indicating the number of
+///     valid detections per batch item. Only the top num_detections[i] entries in
+///     nms_boxes[i], nms_scores[i] and nms_class[i] are valid. The rest of the
+///     entries are zero paddings.
+@inlinable @inline(__always)
+public static func combinedNonMaxSuppression(
+  boxes: Tensor<Float>,
+  scores: Tensor<Float>,
+  maxOutputSizePerClass: Tensor<Int32>,
+  maxTotalSize: Tensor<Int32>,
+  iouThreshold: Tensor<Float>,
+  scoreThreshold: Tensor<Float>,
+  padPerClass: Bool = false,
+  clipBoxes: Bool = true
+) -> (nmsedBoxes: Tensor<Float>, nmsedScores: Tensor<Float>, nmsedClasses: Tensor<Float>, validDetections: Tensor<Int32>) {
+  let op = TFE_Op("CombinedNonMaxSuppression")
+  op.setAttr("pad_per_class", padPerClass)
+  op.setAttr("clip_boxes", clipBoxes)
+  let _ = op.addInput(boxes)
+  let _ = op.addInput(scores)
+  let _ = op.addInput(maxOutputSizePerClass)
+  let _ = op.addInput(maxTotalSize)
+  let _ = op.addInput(iouThreshold)
+  let _ = op.addInput(scoreThreshold)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Compare values of `input` to `threshold` and pack resulting bits into a `uint8`.
+///
+/// Each comparison returns a boolean `true` (if `input_value > threshold`)
+/// or and `false` otherwise.
+///
+/// This operation is useful for Locality-Sensitive-Hashing (LSH) and other
+/// algorithms that use hashing approximations of cosine and `L2` distances;
+/// codes can be generated from an input via:
+///
+/// ```python
+/// codebook_size = 50
+/// codebook_bits = codebook_size * 32
+/// codebook = tf.get_variable('codebook', [x.shape[-1].value, codebook_bits],
+///                            dtype=x.dtype,
+///                            initializer=tf.orthogonal_initializer())
+/// codes = compare_and_threshold(tf.matmul(x, codebook), threshold=0.)
+/// codes = tf.bitcast(codes, tf.int32)  # go from uint8 to int32
+/// # now codes has shape x.shape[:-1] + [codebook_size]
+/// ```
+///
+/// **NOTE**: Currently, the innermost dimension of the tensor must be divisible
+/// by 8.
+///
+/// Given an `input` shaped `[s0, s1, ..., s_n]`, the output is
+/// a `uint8` tensor shaped `[s0, s1, ..., s_n / 8]`.
+///
+/// - Parameters:
+///   - input: Values to compare against `threshold` and bitpack.
+///   - threshold: Threshold to compare against.
+///
+/// - Attr T: The type of the input and threshold.
+///
+/// - Output output: The bitpacked comparisons.
+@inlinable @inline(__always)
+public static func compareAndBitpack<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  threshold: Tensor<T>
+) -> Tensor<UInt8> {
+  let op = TFE_Op("CompareAndBitpack")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(threshold)
+  return op.execute(Int(1))
+}
+
+/// Converts two real numbers to a complex number.
+///
+/// Given a tensor `real` representing the real part of a complex number, and a
+/// tensor `imag` representing the imaginary part of a complex number, this
+/// operation returns complex numbers elementwise of the form \\(a + bj\\), where
+/// *a* represents the `real` part and *b* represents the `imag` part.
+///
+/// The input tensors `real` and `imag` must have the same shape.
+///
+/// For example:
+///
+/// ```
+/// # tensor 'real' is [2.25, 3.25]
+/// # tensor `imag` is [4.75, 5.75]
+/// tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]]
+/// ```
+@inlinable @inline(__always)
+public static func complex<
+    T: FloatingPoint & TensorFlowScalar,
+    Tout: TensorFlowScalar
+>(
+  real: Tensor<T>,
+  imag: Tensor<T>
+) -> Tensor<Tout> {
+  let op = TFE_Op("Complex")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tout", Tout.tensorFlowDataType)
+  let _ = op.addInput(real)
+  let _ = op.addInput(imag)
+  return op.execute(Int(1))
+}
+
+/// Computes the complex absolute value of a tensor.
+///
+/// Given a tensor `x` of complex numbers, this operation returns a tensor of type
+/// `float` or `double` that is the absolute value of each element in `x`. All
+/// elements in `x` must be complex numbers of the form \\(a + bj\\). The absolute
+/// value is computed as \\( \sqrt{a^2 + b^2}\\).
+@inlinable @inline(__always)
+public static func complexAbs<
+    T: TensorFlowScalar,
+    Tout: FloatingPoint & TensorFlowScalar
+>(
+  _ x: Tensor<T>
+) -> Tensor<Tout> {
+  let op = TFE_Op("ComplexAbs")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tout", Tout.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func complexStruct<TC: TensorGroup>(
+  nA: Int64,
+  nB: Int64
+) -> (a: [Tensor<Int32>], b: [Tensor<Int64>], c: TC) {
+  let op = TFE_Op("ComplexStruct")
+  op.setAttr("n_a", nA)
+  op.setAttr("n_b", nB)
+  op.setAttr("t_c", TC._typeList)
+  return op.execute(Int(nA), Int(nB), Int(TC._typeList.count))
+}
+
+/// Computes the ids of the positions in sampled_candidates that match true_labels.
+///
+/// When doing log-odds NCE, the result of this op should be passed through a
+/// SparseToDense op, then added to the logits of the sampled candidates. This has
+/// the effect of 'removing' the sampled labels that match the true labels by
+/// making the classifier sure that they are sampled labels.
+///
+/// - Parameters:
+///   - true_classes: The true_classes output of UnpackSparseLabels.
+///   - sampled_candidates: The sampled_candidates output of CandidateSampler.
+///
+/// - Attrs:
+///   - num_true: Number of true labels per context.
+///   - seed: If either seed or seed2 are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///   - indices: A vector of indices corresponding to rows of true_candidates.
+///   - ids: A vector of IDs of positions in sampled_candidates that match a true_label
+///     for the row with the corresponding index in indices.
+///   - weights: A vector of the same length as indices and ids, in which each element
+///     is -FLOAT_MAX.
+@inlinable @inline(__always)
+public static func computeAccidentalHits(
+  trueClasses: Tensor<Int64>,
+  sampledCandidates: Tensor<Int64>,
+  numTrue: Int64,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> (indices: Tensor<Int32>, ids: Tensor<Int64>, weights: Tensor<Float>) {
+  let op = TFE_Op("ComputeAccidentalHits")
+  op.setAttr("num_true", numTrue)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(trueClasses)
+  let _ = op.addInput(sampledCandidates)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Concatenates tensors along one dimension.
+///
+/// - Parameters:
+///   - concat_dim: 0-D.  The dimension along which to concatenate.  Must be in the
+///     range [0, rank(values)).
+///   - values: The `N` Tensors to concatenate. Their ranks and types must match,
+///     and their sizes must match in all dimensions except `concat_dim`.
+///
+/// - Output output: A `Tensor` with the concatenation of values stacked along the
+///   `concat_dim` dimension.  This tensor's shape matches that of `values` except
+///   in `concat_dim` where it has the sum of the sizes.
+@inlinable @inline(__always)
+public static func concat<T: TensorFlowScalar>(
+  concatDim: Tensor<Int32>,
+  _ values: [Tensor<T>]
+) -> Tensor<T> {
+  let op = TFE_Op("Concat")
+  op.setAttr("N", values.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(concatDim)
+  let _ = op.addInputList(values)
+  return op.execute(Int(1))
+}
+
+/// Computes offsets of concat inputs within its output.
+///
+/// For example:
+///
+/// ```
+/// # 'x' is [2, 2, 7]
+/// # 'y' is [2, 3, 7]
+/// # 'z' is [2, 5, 7]
+/// concat_offset(2, [x, y, z]) => [0, 0, 0], [0, 2, 0], [0, 5, 0]
+/// ```
+///
+/// This is typically used by gradient computations for a concat operation.
+///
+/// - Parameters:
+///   - concat_dim: The dimension along which to concatenate.
+///   - shape: The `N` int32 vectors representing shape of tensors being concatenated.
+///
+/// - Output offset: The `N` int32 vectors representing the starting offset
+///   of input tensors within the concatenated output.
+@inlinable @inline(__always)
+public static func concatOffset(
+  concatDim: Tensor<Int32>,
+  shape: [Tensor<Int32>]
+) -> [Tensor<Int32>] {
+  let op = TFE_Op("ConcatOffset")
+  op.setAttr("N", shape.count)
+  let _ = op.addInput(concatDim)
+  let _ = op.addInputList(shape)
+  return op.execute(Int(shape.count))
+}
+
+/// Concatenates tensors along one dimension.
+///
+/// - Parameters:
+///   - values: List of `N` Tensors to concatenate. Their ranks and types must match,
+///     and their sizes must match in all dimensions except `concat_dim`.
+///   - axis: 0-D.  The dimension along which to concatenate.  Must be in the
+///     range [-rank(values), rank(values)).
+///
+/// - Output output: A `Tensor` with the concatenation of values stacked along the
+///   `concat_dim` dimension.  This tensor's shape matches that of `values` except
+///   in `concat_dim` where it has the sum of the sizes.
+@inlinable @inline(__always)
+public static func concatV2<
+    T: TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  _ values: [Tensor<T>],
+  axis: Tensor<Tidx>
+) -> Tensor<T> {
+  let op = TFE_Op("ConcatV2")
+  op.setAttr("N", values.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInputList(values)
+  let _ = op.addInput(axis)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that concatenates `input_dataset` with `another_dataset`.
+@inlinable @inline(__always)
+public static func concatenateDataset(
+  inputDataset: VariantHandle,
+  anotherDataset: VariantHandle,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ConcatenateDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(anotherDataset)
+  return op.execute(Int(1))
+}
+
+/// Sets up the centralized structures for a distributed TPU system.
+///
+/// - Attrs:
+///   - embedding_config: Reserved. Do not use.
+///   - tpu_embedding_config: Serialized tensorflow.tpu.TPUEmbeddingConfiguration that
+///     describes the embedding lookups of the program.
+///   - is_global_init: Reserved. Do not use.
+///
+/// - Output topology: A serialized tensorflow.tpu.TopologyProto that describes the TPU
+///   topology.
+@inlinable @inline(__always)
+public static func configureDistributedTPU(
+  embeddingConfig: String,
+  tpuEmbeddingConfig: String,
+  isGlobalInit: Bool = false
+) -> StringTensor {
+  let op = TFE_Op("ConfigureDistributedTPU")
+  op.setAttr("embedding_config", embeddingConfig)
+  op.setAttr("tpu_embedding_config", tpuEmbeddingConfig)
+  op.setAttr("is_global_init", isGlobalInit)
+  return op.execute(Int(1))
+}
+
+/// Returns the complex conjugate of a complex number.
+///
+/// Given a tensor `input` of complex numbers, this operation returns a tensor of
+/// complex numbers that are the complex conjugate of each element in `input`. The
+/// complex numbers in `input` must be of the form \\(a + bj\\), where *a* is the
+/// real part and *b* is the imaginary part.
+///
+/// The complex conjugate returned by this operation is of the form \\(a - bj\\).
+///
+/// For example:
+///
+/// ```
+/// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
+/// tf.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]
+/// ```
+@inlinable @inline(__always)
+public static func conj<T: TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Conj")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Shuffle dimensions of x according to a permutation and conjugate the result.
+///
+/// The output `y` has the same rank as `x`. The shapes of `x` and `y` satisfy:
+///   `y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]`
+///   `y[i,j,k,...,s,t,u] == conj(x[perm[i], perm[j], perm[k],...,perm[s], perm[t], perm[u]])`
+@inlinable @inline(__always)
+public static func conjugateTranspose<
+    T: TensorFlowScalar,
+    Tperm: BinaryInteger & TensorFlowScalar
+>(
+  _ x: Tensor<T>,
+  perm: Tensor<Tperm>
+) -> Tensor<T> {
+  let op = TFE_Op("ConjugateTranspose")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tperm", Tperm.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(perm)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func constructionFails(
+) {
+  let op = TFE_Op("ConstructionFails")
+  
+  op.execute()
+}
+
+/// This op consumes a lock created by `MutexLock`.
+///
+/// This op exists to consume a tensor created by `MutexLock` (other than
+/// direct control dependencies).  It should be the only that consumes the tensor,
+/// and will raise an error if it is not.  Its only purpose is to keep the
+/// mutex lock tensor alive until it is consumed by this op.
+///
+/// **NOTE**: This operation must run on the same device as its input.  This may
+/// be enforced via the `colocate_with` mechanism.
+///
+/// - Parameter mutex_lock: A tensor returned by `MutexLock`.
+@inlinable @inline(__always)
+public static func consumeMutexLock(
+  mutexLock: VariantHandle
+) {
+  let op = TFE_Op("ConsumeMutexLock")
+  let _ = op.addInput(mutexLock)
+  op.execute()
+}
+
+/// Does nothing. Serves as a control trigger for scheduling.
+///
+/// Only useful as a placeholder for control edges.
+@inlinable @inline(__always)
+public static func controlTrigger(
+) {
+  let op = TFE_Op("ControlTrigger")
+  
+  op.execute()
+}
+
+/// Computes a 2-D convolution given 4-D `input` and `filter` tensors.
+///
+/// Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
+/// and a filter / kernel tensor of shape
+/// `[filter_height, filter_width, in_channels, out_channels]`, this op
+/// performs the following:
+///
+/// 1. Flattens the filter to a 2-D matrix with shape
+///    `[filter_height * filter_width * in_channels, output_channels]`.
+/// 2. Extracts image patches from the input tensor to form a *virtual*
+///    tensor of shape `[batch, out_height, out_width,
+///    filter_height * filter_width * in_channels]`.
+/// 3. For each patch, right-multiplies the filter matrix and the image patch
+///    vector.
+///
+/// In detail, with the default NHWC format,
+///
+///     output[b, i, j, k] =
+///         sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] *
+///                         filter[di, dj, q, k]
+///
+/// Must have `strides[0] = strides[3] = 1`.  For the most common case of the same
+/// horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
+///
+/// - Parameters:
+///   - input: A 4-D tensor. The dimension order is interpreted according to the value
+///     of `data_format`, see below for details.
+///   - filter: A 4-D tensor of shape
+///     `[filter_height, filter_width, in_channels, out_channels]`
+///
+/// - Attrs:
+///   - strides: 1-D tensor of length 4.  The stride of the sliding window for each
+///     dimension of `input`. The dimension order is determined by the value of
+///     `data_format`, see below for details.
+///   - padding: The type of padding algorithm to use.
+///   - explicit_paddings: If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
+///     dimension, the amount of padding inserted before and after the dimension is
+///     `explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
+///     `padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, height, width, channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, channels, height, width].
+///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///     `input`. If set to k > 1, there will be k-1 skipped cells between each
+///     filter element on that dimension. The dimension order is determined by the
+///     value of `data_format`, see above for details. Dilations in the batch and
+///     depth dimensions must be 1.
+///
+/// - Output output: A 4-D tensor. The dimension order is determined by the value of
+///   `data_format`, see below for details.
+@inlinable @inline(__always)
+public static func conv2D<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  filter: Tensor<T>,
+  strides: [Int32],
+  useCudnnOnGpu: Bool = true,
+  padding: Padding2,
+  explicitPaddings: [Int32],
+  dataFormat: DataFormat = .nhwc,
+  dilations: [Int32] = [1, 1, 1, 1]
+) -> Tensor<T> {
+  let op = TFE_Op("Conv2D")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("use_cudnn_on_gpu", useCudnnOnGpu)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("explicit_paddings", explicitPaddings)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradients of convolution with respect to the filter.
+///
+/// - Parameters:
+///   - input: 4-D with shape `[batch, in_height, in_width, in_channels]`.
+///   - filter_sizes: An integer vector representing the tensor shape of `filter`,
+///     where `filter` is a 4-D
+///     `[filter_height, filter_width, in_channels, out_channels]` tensor.
+///   - out_backprop: 4-D with shape `[batch, out_height, out_width, out_channels]`.
+///     Gradients w.r.t. the output of the convolution.
+///
+/// - Attrs:
+///   - strides: The stride of the sliding window for each dimension of the input
+///     of the convolution. Must be in the same order as the dimension specified with
+///     format.
+///   - padding: The type of padding algorithm to use.
+///   - explicit_paddings: If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
+///     dimension, the amount of padding inserted before and after the dimension is
+///     `explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
+///     `padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, in_channels, in_height, in_width].
+///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///     `input`. If set to k > 1, there will be k-1 skipped cells between each filter
+///     element on that dimension. The dimension order is determined by the value of
+///     `data_format`, see above for details. Dilations in the batch and depth
+///     dimensions must be 1.
+///
+/// - Output output: 4-D with shape
+///   `[filter_height, filter_width, in_channels, out_channels]`.  Gradient w.r.t.
+///   the `filter` input of the convolution.
+@inlinable @inline(__always)
+public static func conv2DBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  filterSizes: Tensor<Int32>,
+  outBackprop: Tensor<T>,
+  strides: [Int32],
+  useCudnnOnGpu: Bool = true,
+  padding: Padding2,
+  explicitPaddings: [Int32],
+  dataFormat: DataFormat = .nhwc,
+  dilations: [Int32] = [1, 1, 1, 1]
+) -> Tensor<T> {
+  let op = TFE_Op("Conv2DBackpropFilter")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("use_cudnn_on_gpu", useCudnnOnGpu)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("explicit_paddings", explicitPaddings)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filterSizes)
+  let _ = op.addInput(outBackprop)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradients of convolution with respect to the input.
+///
+/// - Parameters:
+///   - input_sizes: An integer vector representing the shape of `input`,
+///     where `input` is a 4-D `[batch, height, width, channels]` tensor.
+///   - filter: 4-D with shape
+///     `[filter_height, filter_width, in_channels, out_channels]`.
+///   - out_backprop: 4-D with shape `[batch, out_height, out_width, out_channels]`.
+///     Gradients w.r.t. the output of the convolution.
+///
+/// - Attrs:
+///   - strides: The stride of the sliding window for each dimension of the input
+///     of the convolution. Must be in the same order as the dimension specified with
+///     format.
+///   - padding: The type of padding algorithm to use.
+///   - explicit_paddings: If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
+///     dimension, the amount of padding inserted before and after the dimension is
+///     `explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
+///     `padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, in_channels, in_height, in_width].
+///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///     `input`. If set to k > 1, there will be k-1 skipped cells between each filter
+///     element on that dimension. The dimension order is determined by the value of
+///     `data_format`, see above for details. Dilations in the batch and depth
+///     dimensions must be 1.
+///
+/// - Output output: 4-D with shape `[batch, in_height, in_width, in_channels]`.  Gradient
+///   w.r.t. the input of the convolution.
+@inlinable @inline(__always)
+public static func conv2DBackpropInput<T: FloatingPoint & TensorFlowScalar>(
+  inputSizes: Tensor<Int32>,
+  filter: Tensor<T>,
+  outBackprop: Tensor<T>,
+  strides: [Int32],
+  useCudnnOnGpu: Bool = true,
+  padding: Padding2,
+  explicitPaddings: [Int32],
+  dataFormat: DataFormat = .nhwc,
+  dilations: [Int32] = [1, 1, 1, 1]
+) -> Tensor<T> {
+  let op = TFE_Op("Conv2DBackpropInput")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("use_cudnn_on_gpu", useCudnnOnGpu)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("explicit_paddings", explicitPaddings)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(inputSizes)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(outBackprop)
+  return op.execute(Int(1))
+}
+
+/// Computes a 3-D convolution given 5-D `input` and `filter` tensors.
+///
+/// In signal processing, cross-correlation is a measure of similarity of
+/// two waveforms as a function of a time-lag applied to one of them. This
+/// is also known as a sliding dot product or sliding inner-product.
+///
+/// Our Conv3D implements a form of cross-correlation.
+///
+/// - Parameters:
+///   - input: Shape `[batch, in_depth, in_height, in_width, in_channels]`.
+///   - filter: Shape `[filter_depth, filter_height, filter_width, in_channels,
+///     out_channels]`. `in_channels` must match between `input` and `filter`.
+///
+/// - Attrs:
+///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: The data format of the input and output data. With the
+///     default format "NDHWC", the data is stored in the order of:
+///         [batch, in_depth, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCDHW", the data storage order is:
+///         [batch, in_channels, in_depth, in_height, in_width].
+///   - dilations: 1-D tensor of length 5.  The dilation factor for each dimension of
+///     `input`. If set to k > 1, there will be k-1 skipped cells between each
+///     filter element on that dimension. The dimension order is determined by the
+///     value of `data_format`, see above for details. Dilations in the batch and
+///     depth dimensions must be 1.
+@inlinable @inline(__always)
+public static func conv3D<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  filter: Tensor<T>,
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat1 = .ndhwc,
+  dilations: [Int32] = [1, 1, 1, 1, 1]
+) -> Tensor<T> {
+  let op = TFE_Op("Conv3D")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradients of 3-D convolution with respect to the filter.
+///
+/// - Parameters:
+///   - input: Shape `[batch, depth, rows, cols, in_channels]`.
+///   - filter: Shape `[depth, rows, cols, in_channels, out_channels]`.
+///     `in_channels` must match between `input` and `filter`.
+///   - out_backprop: Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
+///     out_channels]`.
+///
+/// - Attrs:
+///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///   - padding: The type of padding algorithm to use.
+@inlinable @inline(__always)
+public static func conv3DBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  filter: Tensor<T>,
+  outBackprop: Tensor<T>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1, 1]
+) -> Tensor<T> {
+  let op = TFE_Op("Conv3DBackpropFilter")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(outBackprop)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradients of 3-D convolution with respect to the filter.
+///
+/// - Parameters:
+///   - input: Shape `[batch, depth, rows, cols, in_channels]`.
+///   - filter_sizes: An integer vector representing the tensor shape of `filter`,
+///     where `filter` is a 5-D
+///     `[filter_depth, filter_height, filter_width, in_channels, out_channels]`
+///     tensor.
+///   - out_backprop: Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
+///     out_channels]`.
+///
+/// - Attrs:
+///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: The data format of the input and output data. With the
+///     default format "NDHWC", the data is stored in the order of:
+///         [batch, in_depth, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCDHW", the data storage order is:
+///         [batch, in_channels, in_depth, in_height, in_width].
+///   - dilations: 1-D tensor of length 5.  The dilation factor for each dimension of
+///     `input`. If set to k > 1, there will be k-1 skipped cells between each
+///     filter element on that dimension. The dimension order is determined by the
+///     value of `data_format`, see above for details. Dilations in the batch and
+///     depth dimensions must be 1.
+@inlinable @inline(__always)
+public static func conv3DBackpropFilterV2<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  filterSizes: Tensor<Int32>,
+  outBackprop: Tensor<T>,
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat1 = .ndhwc,
+  dilations: [Int32] = [1, 1, 1, 1, 1]
+) -> Tensor<T> {
+  let op = TFE_Op("Conv3DBackpropFilterV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filterSizes)
+  let _ = op.addInput(outBackprop)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradients of 3-D convolution with respect to the input.
+///
+/// - Parameters:
+///   - input: Shape `[batch, depth, rows, cols, in_channels]`.
+///   - filter: Shape `[depth, rows, cols, in_channels, out_channels]`.
+///     `in_channels` must match between `input` and `filter`.
+///   - out_backprop: Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
+///     out_channels]`.
+///
+/// - Attrs:
+///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///   - padding: The type of padding algorithm to use.
+@inlinable @inline(__always)
+public static func conv3DBackpropInput<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  filter: Tensor<T>,
+  outBackprop: Tensor<T>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1, 1]
+) -> Tensor<T> {
+  let op = TFE_Op("Conv3DBackpropInput")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(outBackprop)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradients of 3-D convolution with respect to the input.
+///
+/// - Parameters:
+///   - input_sizes: An integer vector representing the tensor shape of `input`,
+///     where `input` is a 5-D
+///     `[batch, depth, rows, cols, in_channels]` tensor.
+///   - filter: Shape `[depth, rows, cols, in_channels, out_channels]`.
+///     `in_channels` must match between `input` and `filter`.
+///   - out_backprop: Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
+///     out_channels]`.
+///
+/// - Attrs:
+///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: The data format of the input and output data. With the
+///     default format "NDHWC", the data is stored in the order of:
+///         [batch, in_depth, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCDHW", the data storage order is:
+///         [batch, in_channels, in_depth, in_height, in_width].
+///   - dilations: 1-D tensor of length 5.  The dilation factor for each dimension of
+///     `input`. If set to k > 1, there will be k-1 skipped cells between each
+///     filter element on that dimension. The dimension order is determined by the
+///     value of `data_format`, see above for details. Dilations in the batch and
+///     depth dimensions must be 1.
+@inlinable @inline(__always)
+public static func conv3DBackpropInputV2<
+    T: FloatingPoint & TensorFlowScalar,
+    Tshape: BinaryInteger & TensorFlowScalar
+>(
+  inputSizes: Tensor<Tshape>,
+  filter: Tensor<T>,
+  outBackprop: Tensor<T>,
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat1 = .ndhwc,
+  dilations: [Int32] = [1, 1, 1, 1, 1]
+) -> Tensor<T> {
+  let op = TFE_Op("Conv3DBackpropInputV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("dilations", dilations)
+  op.setAttr("Tshape", Tshape.tensorFlowDataType)
+  let _ = op.addInput(inputSizes)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(outBackprop)
+  return op.execute(Int(1))
+}
+
+/// Copy Op.
+///
+/// Performs CPU-to-CPU or GPU-to-GPU deep-copying of tensor, depending on the
+/// device on which the tensor is allocated.
+/// N.B.: If the all downstream attached debug ops are disabled given the current
+/// gRPC gating status, the output will simply forward the input tensor without
+/// deep-copying. See the documentation of Debug* ops for more details.
+///
+/// Unlike the CopyHost Op, this op does not have HostMemory constraint on its
+/// input or output.
+///
+/// - Parameter input: Input tensor.
+///
+/// - Attrs:
+///   - tensor_name: The name of the input tensor.
+///   - debug_ops_spec: A list of debug op spec (op, url, gated_grpc) for attached debug
+///     ops. Each element of the list has the format
+///     <debug_op>;<grpc_url>;<gated_grpc>, wherein gated_grpc is boolean represented
+///     as 0/1. E.g., "DebugIdentity;grpc://foo:3333;1",
+///     "DebugIdentity;file:///tmp/tfdbg_1;0".
+///
+/// - Output output: Output tensor, deep-copied from input.
+@inlinable @inline(__always)
+public static func copy<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  tensorName: String,
+  debugOpsSpec: [String]
+) -> Tensor<T> {
+  let op = TFE_Op("Copy")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("tensor_name", tensorName)
+  op.setAttr("debug_ops_spec", debugOpsSpec)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Copy Host Op.
+///
+/// Performs CPU-to-CPU deep-copying of tensor.
+/// N.B.: If the all downstream attached debug ops are disabled given the current
+/// gRPC gating status, the output will simply forward the input tensor without
+/// deep-copying. See the documentation of Debug* ops for more details.
+///
+/// Unlike the Copy Op, this op has HostMemory constraint on its input or output.
+///
+/// - Parameter input: Input tensor.
+///
+/// - Attrs:
+///   - tensor_name: The name of the input tensor.
+///   - debug_ops_spec: A list of debug op spec (op, url, gated_grpc) for attached debug
+///     ops. Each element of the list has the format
+///     <debug_op>;<grpc_url>;<gated_grpc>, wherein gated_grpc is boolean represented
+///     as 0/1. E.g., "DebugIdentity;grpc://foo:3333;1",
+///     "DebugIdentity;file:///tmp/tfdbg_1;0".
+///
+/// - Output output: Output tensor, deep-copied from input.
+@inlinable @inline(__always)
+public static func copyHost<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  tensorName: String,
+  debugOpsSpec: [String]
+) -> Tensor<T> {
+  let op = TFE_Op("CopyHost")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("tensor_name", tensorName)
+  op.setAttr("debug_ops_spec", debugOpsSpec)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func copyOp<T: TensorFlowScalar>(
+  _ a: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("CopyOp")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  return op.execute(Int(1))
+}
+
+/// Computes cos of x element-wise.
+@inlinable @inline(__always)
+public static func cos<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Cos")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes hyperbolic cosine of x element-wise.
+@inlinable @inline(__always)
+public static func cosh<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Cosh")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func createSummaryDbWriter(
+  writer: ResourceHandle,
+  dbUri: StringTensor,
+  experimentName: StringTensor,
+  runName: StringTensor,
+  userName: StringTensor
+) {
+  let op = TFE_Op("CreateSummaryDbWriter")
+  let _ = op.addInput(writer)
+  let _ = op.addInput(dbUri)
+  let _ = op.addInput(experimentName)
+  let _ = op.addInput(runName)
+  let _ = op.addInput(userName)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func createSummaryFileWriter(
+  writer: ResourceHandle,
+  logdir: StringTensor,
+  maxQueue: Tensor<Int32>,
+  flushMillis: Tensor<Int32>,
+  filenameSuffix: StringTensor
+) {
+  let op = TFE_Op("CreateSummaryFileWriter")
+  let _ = op.addInput(writer)
+  let _ = op.addInput(logdir)
+  let _ = op.addInput(maxQueue)
+  let _ = op.addInput(flushMillis)
+  let _ = op.addInput(filenameSuffix)
+  op.execute()
+}
+
+/// Extracts crops from the input image tensor and resizes them.
+///
+/// Extracts crops from the input image tensor and resizes them using bilinear
+/// sampling or nearest neighbor sampling (possibly with aspect ratio change) to a
+/// common output size specified by `crop_size`. This is more general than the
+/// `crop_to_bounding_box` op which extracts a fixed size slice from the input image
+/// and does not allow resizing or aspect ratio change.
+///
+/// Returns a tensor with `crops` from the input `image` at positions defined at the
+/// bounding box locations in `boxes`. The cropped boxes are all resized (with
+/// bilinear or nearest neighbor interpolation) to a fixed
+/// `size = [crop_height, crop_width]`. The result is a 4-D tensor
+/// `[num_boxes, crop_height, crop_width, depth]`. The resizing is corner aligned.
+/// In particular, if `boxes = [[0, 0, 1, 1]]`, the method will give identical
+/// results to using `tf.image.resize_bilinear()` or
+/// `tf.image.resize_nearest_neighbor()`(depends on the `method` argument) with
+/// `align_corners=True`.
+///
+/// - Parameters:
+///   - image: A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
+///     Both `image_height` and `image_width` need to be positive.
+///   - boxes: A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
+///     specifies the coordinates of a box in the `box_ind[i]` image and is specified
+///     in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of
+///     `y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the
+///     `[0, 1]` interval of normalized image height is mapped to
+///     `[0, image_height - 1]` in image height coordinates. We do allow `y1` > `y2`, in
+///     which case the sampled crop is an up-down flipped version of the original
+///     image. The width dimension is treated similarly. Normalized coordinates
+///     outside the `[0, 1]` range are allowed, in which case we use
+///     `extrapolation_value` to extrapolate the input image values.
+///   - box_ind: A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
+///     The value of `box_ind[i]` specifies the image that the `i`-th box refers to.
+///   - crop_size: A 1-D tensor of 2 elements, `size = [crop_height, crop_width]`. All
+///     cropped image patches are resized to this size. The aspect ratio of the image
+///     content is not preserved. Both `crop_height` and `crop_width` need to be
+///     positive.
+///
+/// - Attrs:
+///   - method: A string specifying the sampling method for resizing. It can be either
+///     `"bilinear"` or `"nearest"` and default to `"bilinear"`. Currently two sampling
+///     methods are supported: Bilinear and Nearest Neighbor.
+///   - extrapolation_value: Value used for extrapolation, when applicable.
+///
+/// - Output crops: A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
+@inlinable @inline(__always)
+public static func cropAndResize<T: Numeric & TensorFlowScalar>(
+  image: Tensor<T>,
+  boxes: Tensor<Float>,
+  boxInd: Tensor<Int32>,
+  cropSize: Tensor<Int32>,
+  method: Method = .bilinear,
+  extrapolationValue: Double = 0
+) -> Tensor<Float> {
+  let op = TFE_Op("CropAndResize")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("method", method.cName)
+  op.setAttr("extrapolation_value", extrapolationValue)
+  let _ = op.addInput(image)
+  let _ = op.addInput(boxes)
+  let _ = op.addInput(boxInd)
+  let _ = op.addInput(cropSize)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient of the crop_and_resize op wrt the input boxes tensor.
+///
+/// - Parameters:
+///   - grads: A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
+///   - image: A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
+///     Both `image_height` and `image_width` need to be positive.
+///   - boxes: A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
+///     specifies the coordinates of a box in the `box_ind[i]` image and is specified
+///     in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of
+///     `y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the
+///     `[0, 1]` interval of normalized image height is mapped to
+///     `[0, image_height - 1] in image height coordinates. We do allow y1 > y2, in
+///     which case the sampled crop is an up-down flipped version of the original
+///     image. The width dimension is treated similarly. Normalized coordinates
+///     outside the `[0, 1]` range are allowed, in which case we use
+///     `extrapolation_value` to extrapolate the input image values.
+///   - box_ind: A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
+///     The value of `box_ind[i]` specifies the image that the `i`-th box refers to.
+///
+/// - Attr method: A string specifying the interpolation method. Only 'bilinear' is
+///   supported for now.
+///
+/// - Output output: A 2-D tensor of shape `[num_boxes, 4]`.
+@inlinable @inline(__always)
+public static func cropAndResizeGradBoxes<T: Numeric & TensorFlowScalar>(
+  grads: Tensor<Float>,
+  image: Tensor<T>,
+  boxes: Tensor<Float>,
+  boxInd: Tensor<Int32>,
+  method: Method3 = .bilinear
+) -> Tensor<Float> {
+  let op = TFE_Op("CropAndResizeGradBoxes")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("method", method.cName)
+  let _ = op.addInput(grads)
+  let _ = op.addInput(image)
+  let _ = op.addInput(boxes)
+  let _ = op.addInput(boxInd)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient of the crop_and_resize op wrt the input image tensor.
+///
+/// - Parameters:
+///   - grads: A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
+///   - boxes: A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
+///     specifies the coordinates of a box in the `box_ind[i]` image and is specified
+///     in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of
+///     `y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the
+///     `[0, 1]` interval of normalized image height is mapped to
+///     `[0, image_height - 1] in image height coordinates. We do allow y1 > y2, in
+///     which case the sampled crop is an up-down flipped version of the original
+///     image. The width dimension is treated similarly. Normalized coordinates
+///     outside the `[0, 1]` range are allowed, in which case we use
+///     `extrapolation_value` to extrapolate the input image values.
+///   - box_ind: A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
+///     The value of `box_ind[i]` specifies the image that the `i`-th box refers to.
+///   - image_size: A 1-D tensor with value `[batch, image_height, image_width, depth]`
+///     containing the original image size. Both `image_height` and `image_width` need
+///     to be positive.
+///
+/// - Attr method: A string specifying the interpolation method. Only 'bilinear' is
+///   supported for now.
+///
+/// - Output output: A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
+@inlinable @inline(__always)
+public static func cropAndResizeGradImage<T: FloatingPoint & TensorFlowScalar>(
+  grads: Tensor<Float>,
+  boxes: Tensor<Float>,
+  boxInd: Tensor<Int32>,
+  imageSize: Tensor<Int32>,
+  method: Method = .bilinear
+) -> Tensor<T> {
+  let op = TFE_Op("CropAndResizeGradImage")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("method", method.cName)
+  let _ = op.addInput(grads)
+  let _ = op.addInput(boxes)
+  let _ = op.addInput(boxInd)
+  let _ = op.addInput(imageSize)
+  return op.execute(Int(1))
+}
+
+/// Compute the pairwise cross product.
+///
+/// `a` and `b` must be the same shape; they can either be simple 3-element vectors,
+/// or any shape where the innermost dimension is 3. In the latter case, each pair
+/// of corresponding 3-element vectors is cross-multiplied independently.
+///
+/// - Parameters:
+///   - a: A tensor containing 3-element vectors.
+///   - b: Another tensor, of same type and shape as `a`.
+///
+/// - Output product: Pairwise cross product of the vectors in `a` and `b`.
+@inlinable @inline(__always)
+public static func cross<T: Numeric & TensorFlowScalar>(
+  _ a: Tensor<T>,
+  _ b: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Cross")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  return op.execute(Int(1))
+}
+
+/// An Op to sum inputs across replicated TPU instances.
+///
+/// Each instance supplies its own input.
+///
+/// For example, suppose there are 8 TPU instances: `[A, B, C, D, E, F, G, H]`.
+/// Passing group_assignment=`[[0,2,4,6],[1,3,5,7]]` sets `A, C, E, G` as group 0,
+/// and `B, D, F, H` as group 1. Thus we get the outputs:
+/// `[A+C+E+G, B+D+F+H, A+C+E+G, B+D+F+H, A+C+E+G, B+D+F+H, A+C+E+G, B+D+F+H]`.
+///
+/// - Parameters:
+///   - input: The local input to the sum.
+///   - group_assignment: An int32 tensor with shape
+///     [num_groups, num_replicas_per_group]. `group_assignment[i]` represents the
+///     replica ids in the ith subgroup.
+///
+/// - Attr T: The type of elements to be summed.
+///
+/// - Output output: The sum of all the distributed inputs.
+@inlinable @inline(__always)
+public static func crossReplicaSum<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  groupAssignment: Tensor<Int32>
+) -> Tensor<T> {
+  let op = TFE_Op("CrossReplicaSum")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(groupAssignment)
+  return op.execute(Int(1))
+}
+
+/// A RNN backed by cuDNN.
+///
+/// Computes the RNN from the input and initial states, with respect to the params
+/// buffer.
+///
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicate whether there is a linear projection between the input and
+///   the actual computation before the first layer. 'skip_input' is only allowed
+///   when input_size == num_units; 'auto_select' implies 'skip_input' when
+///   input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used. Should be
+///   "unidirectional" or "bidirectional".
+/// dropout: Dropout probability. When set to 0., dropout is disabled.
+/// seed: The 1st part of a seed to initialize dropout.
+/// seed2: The 2nd part of a seed to initialize dropout.
+/// input: A 3-D tensor with the shape of [seq_length, batch_size, input_size].
+/// input_h: A 3-D tensor with the shape of [num_layer * dir, batch_size,
+///     num_units].
+/// input_c: For LSTM, a 3-D tensor with the shape of
+///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
+/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
+///     The size must be created through CudnnRNNParamsSize, and initialized
+///     separately. Note that they might not be compatible across different
+///     generations. So it is a good idea to save and restore
+/// output: A 3-D tensor with the shape of [seq_length, batch_size,
+///     dir * num_units].
+/// output_h: The same shape has input_h.
+/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
+/// is_training: Indicates whether this operation is used for inferenece or
+///   training.
+/// reserve_space: An opaque tensor that can be used in backprop calculation. It
+///   is only produced if is_training is false.
+@inlinable @inline(__always)
+public static func cudnnRNN<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  inputH: Tensor<T>,
+  inputC: Tensor<T>,
+  params: Tensor<T>,
+  rnnMode: RnnMode = .lstm,
+  inputMode: InputMode = .linearInput,
+  direction: Direction = .unidirectional,
+  dropout: Double = 0,
+  seed: Int64 = 0,
+  seed2: Int64 = 0,
+  isTraining: Bool = true
+) -> (output: Tensor<T>, outputH: Tensor<T>, outputC: Tensor<T>, reserveSpace: Tensor<T>) {
+  let op = TFE_Op("CudnnRNN")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("rnn_mode", rnnMode.cName)
+  op.setAttr("input_mode", inputMode.cName)
+  op.setAttr("direction", direction.cName)
+  op.setAttr("dropout", dropout)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("is_training", isTraining)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputH)
+  let _ = op.addInput(inputC)
+  let _ = op.addInput(params)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Backprop step of CudnnRNN.
+///
+/// Compute the backprop of both data and weights in a RNN.
+///
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicate whether there is a linear projection between the input and
+///     the actual computation before the first layer. 'skip_input' is only allowed
+///     when input_size == num_units; 'auto_select' implies 'skip_input' when
+///     input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used. Should be
+///   "unidirectional" or "bidirectional".
+/// dropout: Dropout probability. When set to 0., dropout is disabled.
+/// seed: The 1st part of a seed to initialize dropout.
+/// seed2: The 2nd part of a seed to initialize dropout.
+/// input: A 3-D tensor with the shape of [seq_length, batch_size, input_size].
+/// input_h: A 3-D tensor with the shape of [num_layer * dir, batch_size,
+///     num_units].
+/// input_c: For LSTM, a 3-D tensor with the shape of
+///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
+/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
+///     The size must be created through CudnnRNNParamsSize, and initialized
+///     separately. Note that they might not be compatible across different
+///     generations. So it is a good idea to save and restore
+/// output: A 3-D tensor with the shape of [seq_length, batch_size,
+///     dir * num_units].
+/// output_h: The same shape has input_h.
+/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
+/// output_backprop: A 3-D tensor with the same shape as output in the forward pass.
+/// output_h_backprop: A 3-D tensor with the same shape as output_h in the forward
+///     pass.
+/// output_c_backprop: A 3-D tensor with the same shape as output_c in the forward
+///     pass.
+/// reserve_space: The same reserve_space produced in for forward operation.
+/// input_backprop: The backprop to input in the forward pass. Has the same shape
+///     as input.
+/// input_h_backprop: The backprop to input_h in the forward pass. Has the same
+///     shape as input_h.
+/// input_c_backprop: The backprop to input_c in the forward pass. Has the same
+///     shape as input_c.
+/// params_backprop: The backprop to the params buffer in the forward pass. Has the
+///     same shape as params.
+@inlinable @inline(__always)
+public static func cudnnRNNBackprop<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  inputH: Tensor<T>,
+  inputC: Tensor<T>,
+  params: Tensor<T>,
+  output: Tensor<T>,
+  outputH: Tensor<T>,
+  outputC: Tensor<T>,
+  outputBackprop: Tensor<T>,
+  outputHBackprop: Tensor<T>,
+  outputCBackprop: Tensor<T>,
+  reserveSpace: Tensor<T>,
+  rnnMode: RnnMode = .lstm,
+  inputMode: InputMode = .linearInput,
+  direction: Direction = .unidirectional,
+  dropout: Double = 0,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> (inputBackprop: Tensor<T>, inputHBackprop: Tensor<T>, inputCBackprop: Tensor<T>, paramsBackprop: Tensor<T>) {
+  let op = TFE_Op("CudnnRNNBackprop")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("rnn_mode", rnnMode.cName)
+  op.setAttr("input_mode", inputMode.cName)
+  op.setAttr("direction", direction.cName)
+  op.setAttr("dropout", dropout)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputH)
+  let _ = op.addInput(inputC)
+  let _ = op.addInput(params)
+  let _ = op.addInput(output)
+  let _ = op.addInput(outputH)
+  let _ = op.addInput(outputC)
+  let _ = op.addInput(outputBackprop)
+  let _ = op.addInput(outputHBackprop)
+  let _ = op.addInput(outputCBackprop)
+  let _ = op.addInput(reserveSpace)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Backprop step of CudnnRNN.
+///
+/// Compute the backprop of both data and weights in a RNN. Takes an extra
+///     "host_reserved" inupt than CudnnRNNBackprop, which is used to determine RNN
+///     cudnnRNNAlgo_t and cudnnMathType_t.
+///
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicates whether there is a linear projection between the input and
+///     the actual computation before the first layer. 'skip_input' is only allowed
+///     when input_size == num_units; 'auto_select' implies 'skip_input' when
+///     input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used. Should be
+///   "unidirectional" or "bidirectional".
+/// dropout: Dropout probability. When set to 0., dropout is disabled.
+/// seed: The 1st part of a seed to initialize dropout.
+/// seed2: The 2nd part of a seed to initialize dropout.
+/// input: A 3-D tensor with the shape of [seq_length, batch_size, input_size].
+/// input_h: A 3-D tensor with the shape of [num_layer * dir, batch_size,
+///     num_units].
+/// input_c: For LSTM, a 3-D tensor with the shape of
+///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
+/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
+///     The size must be created through CudnnRNNParamsSize, and initialized
+///     separately. Note that they might not be compatible across different
+///     generations. So it is a good idea to save and restore
+/// output: A 3-D tensor with the shape of [seq_length, batch_size,
+///     dir * num_units].
+/// output_h: The same shape has input_h.
+/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
+/// output_backprop: A 3-D tensor with the same shape as output in the forward pass.
+/// output_h_backprop: A 3-D tensor with the same shape as output_h in the forward
+///     pass.
+/// output_c_backprop: A 3-D tensor with the same shape as output_c in the forward
+///     pass.
+/// reserve_space: The same reserve_space produced in the forward operation.
+/// host_reserved: The same host_reserved produced in the forward operation.
+/// input_backprop: The backprop to input in the forward pass. Has the same shape
+///     as input.
+/// input_h_backprop: The backprop to input_h in the forward pass. Has the same
+///     shape as input_h.
+/// input_c_backprop: The backprop to input_c in the forward pass. Has the same
+///     shape as input_c.
+/// params_backprop: The backprop to the params buffer in the forward pass. Has the
+///     same shape as params.
+@inlinable @inline(__always)
+public static func cudnnRNNBackpropV2<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  inputH: Tensor<T>,
+  inputC: Tensor<T>,
+  params: Tensor<T>,
+  output: Tensor<T>,
+  outputH: Tensor<T>,
+  outputC: Tensor<T>,
+  outputBackprop: Tensor<T>,
+  outputHBackprop: Tensor<T>,
+  outputCBackprop: Tensor<T>,
+  reserveSpace: Tensor<T>,
+  hostReserved: Tensor<Int8>,
+  rnnMode: RnnMode = .lstm,
+  inputMode: InputMode = .linearInput,
+  direction: Direction = .unidirectional,
+  dropout: Double = 0,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> (inputBackprop: Tensor<T>, inputHBackprop: Tensor<T>, inputCBackprop: Tensor<T>, paramsBackprop: Tensor<T>) {
+  let op = TFE_Op("CudnnRNNBackpropV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("rnn_mode", rnnMode.cName)
+  op.setAttr("input_mode", inputMode.cName)
+  op.setAttr("direction", direction.cName)
+  op.setAttr("dropout", dropout)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputH)
+  let _ = op.addInput(inputC)
+  let _ = op.addInput(params)
+  let _ = op.addInput(output)
+  let _ = op.addInput(outputH)
+  let _ = op.addInput(outputC)
+  let _ = op.addInput(outputBackprop)
+  let _ = op.addInput(outputHBackprop)
+  let _ = op.addInput(outputCBackprop)
+  let _ = op.addInput(reserveSpace)
+  let _ = op.addInput(hostReserved)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Backprop step of CudnnRNNV3.
+///
+/// Compute the backprop of both data and weights in a RNN. Takes an extra
+///     "sequence_lengths" input than CudnnRNNBackprop.
+///
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicates whether there is a linear projection between the input and
+///     the actual computation before the first layer. 'skip_input' is only allowed
+///     when input_size == num_units; 'auto_select' implies 'skip_input' when
+///     input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used. Should be
+///   "unidirectional" or "bidirectional".
+/// dropout: Dropout probability. When set to 0., dropout is disabled.
+/// seed: The 1st part of a seed to initialize dropout.
+/// seed2: The 2nd part of a seed to initialize dropout.
+/// input: If time_major is true, this is a 3-D tensor with the shape of
+///     [seq_length, batch_size, input_size]. If time_major is false, the shape is
+///     [batch_size, seq_length, input_size].
+/// input_h: If time_major is true, this is a 3-D tensor with the shape of
+///     [num_layer * dir, batch_size, num_units]. If time_major is false, the shape
+///     is [batch_size, num_layer * dir, num_units].
+/// input_c: For LSTM, a 3-D tensor with the shape of
+///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
+/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
+///     The size must be created through CudnnRNNParamsSize, and initialized
+///     separately. Note that they might not be compatible across different
+///     generations. So it is a good idea to save and restore
+/// sequence_lengths: a vector of lengths of each input sequence.
+/// output: If time_major is true, this is a 3-D tensor with the shape of
+///     [seq_length, batch_size, dir * num_units]. If time_major is false, the
+///     shape is [batch_size, seq_length, dir * num_units].
+/// output_h: The same shape has input_h.
+/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
+/// output_backprop: A 3-D tensor with the same shape as output in the forward pass.
+/// output_h_backprop: A 3-D tensor with the same shape as output_h in the forward
+///     pass.
+/// output_c_backprop: A 3-D tensor with the same shape as output_c in the forward
+///     pass.
+/// time_major: Indicates whether the input/output format is time major or batch
+///     major.
+/// reserve_space: The same reserve_space produced in the forward operation.
+/// input_backprop: The backprop to input in the forward pass. Has the same shape
+///     as input.
+/// input_h_backprop: The backprop to input_h in the forward pass. Has the same
+///     shape as input_h.
+/// input_c_backprop: The backprop to input_c in the forward pass. Has the same
+///     shape as input_c.
+/// params_backprop: The backprop to the params buffer in the forward pass. Has the
+///     same shape as params.
+@inlinable @inline(__always)
+public static func cudnnRNNBackpropV3<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  inputH: Tensor<T>,
+  inputC: Tensor<T>,
+  params: Tensor<T>,
+  sequenceLengths: Tensor<Int32>,
+  output: Tensor<T>,
+  outputH: Tensor<T>,
+  outputC: Tensor<T>,
+  outputBackprop: Tensor<T>,
+  outputHBackprop: Tensor<T>,
+  outputCBackprop: Tensor<T>,
+  reserveSpace: Tensor<T>,
+  hostReserved: Tensor<Int8>,
+  rnnMode: RnnMode = .lstm,
+  inputMode: InputMode = .linearInput,
+  direction: Direction = .unidirectional,
+  dropout: Double = 0,
+  seed: Int64 = 0,
+  seed2: Int64 = 0,
+  timeMajor: Bool = true
+) -> (inputBackprop: Tensor<T>, inputHBackprop: Tensor<T>, inputCBackprop: Tensor<T>, paramsBackprop: Tensor<T>) {
+  let op = TFE_Op("CudnnRNNBackpropV3")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("rnn_mode", rnnMode.cName)
+  op.setAttr("input_mode", inputMode.cName)
+  op.setAttr("direction", direction.cName)
+  op.setAttr("dropout", dropout)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("time_major", timeMajor)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputH)
+  let _ = op.addInput(inputC)
+  let _ = op.addInput(params)
+  let _ = op.addInput(sequenceLengths)
+  let _ = op.addInput(output)
+  let _ = op.addInput(outputH)
+  let _ = op.addInput(outputC)
+  let _ = op.addInput(outputBackprop)
+  let _ = op.addInput(outputHBackprop)
+  let _ = op.addInput(outputCBackprop)
+  let _ = op.addInput(reserveSpace)
+  let _ = op.addInput(hostReserved)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Converts CudnnRNN params from canonical form to usable form.
+///
+/// Writes a set of weights into the opaque params buffer so they can be used in
+/// upcoming training or inferences.
+///
+/// Note that the params buffer may not be compatible across different GPUs. So any
+/// save and restoration should be converted to and from the canonical weights and
+/// biases.
+///
+/// num_layers: Specifies the number of layers in the RNN model.
+/// num_units: Specifies the size of the hidden state.
+/// input_size: Specifies the size of the input state.
+/// weights: the canonical form of weights that can be used for saving
+///     and restoration. They are more likely to be compatible across different
+///     generations.
+/// biases: the canonical form of biases that can be used for saving
+///     and restoration. They are more likely to be compatible across different
+///     generations.
+/// num_params: number of parameter sets for all layers.
+///     Each layer may contain multiple parameter sets, with each set consisting of
+///     a weight matrix and a bias vector.
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicate whether there is a linear projection between the input and
+///     The actual computation before the first layer. 'skip_input' is only allowed
+///     when input_size == num_units; 'auto_select' implies 'skip_input' when
+///     input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used.
+///     dir = (direction == bidirectional) ? 2 : 1
+/// dropout: dropout probability. When set to 0., dropout is disabled.
+/// seed: the 1st part of a seed to initialize dropout.
+/// seed2: the 2nd part of a seed to initialize dropout.
+@inlinable @inline(__always)
+public static func cudnnRNNCanonicalToParams<T: FloatingPoint & TensorFlowScalar>(
+  numLayers: Tensor<Int32>,
+  numUnits: Tensor<Int32>,
+  inputSize: Tensor<Int32>,
+  weights: [Tensor<T>],
+  biases: [Tensor<T>],
+  rnnMode: RnnMode = .lstm,
+  inputMode: InputMode = .linearInput,
+  direction: Direction = .unidirectional,
+  dropout: Double = 0,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<T> {
+  let op = TFE_Op("CudnnRNNCanonicalToParams")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("num_params", weights.count)
+  op.setAttr("rnn_mode", rnnMode.cName)
+  op.setAttr("input_mode", inputMode.cName)
+  op.setAttr("direction", direction.cName)
+  op.setAttr("dropout", dropout)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(numLayers)
+  let _ = op.addInput(numUnits)
+  let _ = op.addInput(inputSize)
+  let _ = op.addInputList(weights)
+  let _ = op.addInputList(biases)
+  return op.execute(Int(1))
+}
+
+/// Computes size of weights that can be used by a Cudnn RNN model.
+///
+/// Return the params size that can be used by the Cudnn RNN model. Subsequent
+/// weight allocation and initialization should use this size.
+///
+/// num_layers: Specifies the number of layers in the RNN model.
+/// num_units: Specifies the size of the hidden state.
+/// input_size: Specifies the size of the input state.
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicate whether there is a linear projection between the input and
+///   The actual computation before the first layer. 'skip_input' is only allowed
+///   when input_size == num_units; 'auto_select' implies 'skip_input' when
+///   input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used.
+///   dir = (direction == bidirectional) ? 2 : 1
+/// dropout: dropout probability. When set to 0., dropout is disabled.
+/// seed: the 1st part of a seed to initialize dropout.
+/// seed2: the 2nd part of a seed to initialize dropout.
+/// params_size: The size of the params buffer that should be allocated and
+///   initialized for this RNN model. Note that this params buffer may not be
+///   compatible across GPUs. Please use CudnnRNNParamsWeights and
+///   CudnnRNNParamsBiases to save and restore them in a way that is compatible
+///   across different runs.
+@inlinable @inline(__always)
+public static func cudnnRNNParamsSize<S: BinaryInteger & TensorFlowScalar>(
+  numLayers: Tensor<Int32>,
+  numUnits: Tensor<Int32>,
+  inputSize: Tensor<Int32>,
+  t: TensorDataType,
+  rnnMode: RnnMode = .lstm,
+  inputMode: InputMode = .linearInput,
+  direction: Direction = .unidirectional,
+  dropout: Double = 0,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<S> {
+  let op = TFE_Op("CudnnRNNParamsSize")
+  op.setAttr("T", t)
+  op.setAttr("S", S.tensorFlowDataType)
+  op.setAttr("rnn_mode", rnnMode.cName)
+  op.setAttr("input_mode", inputMode.cName)
+  op.setAttr("direction", direction.cName)
+  op.setAttr("dropout", dropout)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(numLayers)
+  let _ = op.addInput(numUnits)
+  let _ = op.addInput(inputSize)
+  return op.execute(Int(1))
+}
+
+/// Retrieves CudnnRNN params in canonical form.
+///
+/// Retrieves a set of weights from the opaque params buffer that can be saved and
+/// restored in a way compatible with future runs.
+///
+/// Note that the params buffer may not be compatible across different GPUs. So any
+/// save and restoration should be converted to and from the canonical weights and
+/// biases.
+///
+/// num_layers: Specifies the number of layers in the RNN model.
+/// num_units: Specifies the size of the hidden state.
+/// input_size: Specifies the size of the input state.
+/// num_params: number of parameter sets for all layers.
+///     Each layer may contain multiple parameter sets, with each set consisting of
+///     a weight matrix and a bias vector.
+/// weights: the canonical form of weights that can be used for saving
+///     and restoration. They are more likely to be compatible across different
+///     generations.
+/// biases: the canonical form of biases that can be used for saving
+///     and restoration. They are more likely to be compatible across different
+///     generations.
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicate whether there is a linear projection between the input and
+///     The actual computation before the first layer. 'skip_input' is only allowed
+///     when input_size == num_units; 'auto_select' implies 'skip_input' when
+///     input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used.
+///     dir = (direction == bidirectional) ? 2 : 1
+/// dropout: dropout probability. When set to 0., dropout is disabled.
+/// seed: the 1st part of a seed to initialize dropout.
+/// seed2: the 2nd part of a seed to initialize dropout.
+@inlinable @inline(__always)
+public static func cudnnRNNParamsToCanonical<T: FloatingPoint & TensorFlowScalar>(
+  numLayers: Tensor<Int32>,
+  numUnits: Tensor<Int32>,
+  inputSize: Tensor<Int32>,
+  params: Tensor<T>,
+  numParams: Int64,
+  rnnMode: RnnMode = .lstm,
+  inputMode: InputMode = .linearInput,
+  direction: Direction = .unidirectional,
+  dropout: Double = 0,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> (weights: [Tensor<T>], biases: [Tensor<T>]) {
+  let op = TFE_Op("CudnnRNNParamsToCanonical")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("num_params", numParams)
+  op.setAttr("rnn_mode", rnnMode.cName)
+  op.setAttr("input_mode", inputMode.cName)
+  op.setAttr("direction", direction.cName)
+  op.setAttr("dropout", dropout)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(numLayers)
+  let _ = op.addInput(numUnits)
+  let _ = op.addInput(inputSize)
+  let _ = op.addInput(params)
+  return op.execute(Int(numParams), Int(numParams))
+}
+
+/// A RNN backed by cuDNN.
+///
+/// Computes the RNN from the input and initial states, with respect to the params
+/// buffer. Produces one extra output "host_reserved" than CudnnRNN.
+///
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicates whether there is a linear projection between the input and
+///   the actual computation before the first layer. 'skip_input' is only allowed
+///   when input_size == num_units; 'auto_select' implies 'skip_input' when
+///   input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used. Should be
+///   "unidirectional" or "bidirectional".
+/// dropout: Dropout probability. When set to 0., dropout is disabled.
+/// seed: The 1st part of a seed to initialize dropout.
+/// seed2: The 2nd part of a seed to initialize dropout.
+/// input: A 3-D tensor with the shape of [seq_length, batch_size, input_size].
+/// input_h: A 3-D tensor with the shape of [num_layer * dir, batch_size,
+///     num_units].
+/// input_c: For LSTM, a 3-D tensor with the shape of
+///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
+/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
+///     The size must be created through CudnnRNNParamsSize, and initialized
+///     separately. Note that they might not be compatible across different
+///     generations. So it is a good idea to save and restore
+/// output: A 3-D tensor with the shape of [seq_length, batch_size,
+///     dir * num_units].
+/// output_h: The same shape has input_h.
+/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
+/// is_training: Indicates whether this operation is used for inferenece or
+///   training.
+/// reserve_space: An opaque tensor that can be used in backprop calculation. It
+///   is only produced if is_training is true.
+/// host_reserved: An opaque tensor that can be used in backprop calculation. It is
+///   only produced if is_training is true. It is output on host memory rather than
+///   device memory.
+@inlinable @inline(__always)
+public static func cudnnRNNV2<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  inputH: Tensor<T>,
+  inputC: Tensor<T>,
+  params: Tensor<T>,
+  rnnMode: RnnMode = .lstm,
+  inputMode: InputMode = .linearInput,
+  direction: Direction = .unidirectional,
+  dropout: Double = 0,
+  seed: Int64 = 0,
+  seed2: Int64 = 0,
+  isTraining: Bool = true
+) -> (output: Tensor<T>, outputH: Tensor<T>, outputC: Tensor<T>, reserveSpace: Tensor<T>, hostReserved: Tensor<Int8>) {
+  let op = TFE_Op("CudnnRNNV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("rnn_mode", rnnMode.cName)
+  op.setAttr("input_mode", inputMode.cName)
+  op.setAttr("direction", direction.cName)
+  op.setAttr("dropout", dropout)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("is_training", isTraining)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputH)
+  let _ = op.addInput(inputC)
+  let _ = op.addInput(params)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// A RNN backed by cuDNN.
+///
+/// Computes the RNN from the input and initial states, with respect to the params
+/// buffer. Accepts one extra input "sequence_lengths" than CudnnRNN.
+///
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicates whether there is a linear projection between the input and
+///   the actual computation before the first layer. 'skip_input' is only allowed
+///   when input_size == num_units; 'auto_select' implies 'skip_input' when
+///   input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used. Should be
+///   "unidirectional" or "bidirectional".
+/// dropout: Dropout probability. When set to 0., dropout is disabled.
+/// seed: The 1st part of a seed to initialize dropout.
+/// seed2: The 2nd part of a seed to initialize dropout.
+/// input: If time_major is true, this is a 3-D tensor with the shape of
+///     [seq_length, batch_size, input_size]. If time_major is false, the shape is
+///     [batch_size, seq_length, input_size].
+/// input_h: If time_major is true, this is a 3-D tensor with the shape of
+///     [num_layer * dir, batch_size, num_units]. If time_major is false, the shape
+///     is [batch_size, num_layer * dir, num_units].
+/// input_c: For LSTM, a 3-D tensor with the shape of
+///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
+/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
+///     The size must be created through CudnnRNNParamsSize, and initialized
+///     separately. Note that they might not be compatible across different
+///     generations. So it is a good idea to save and restore
+/// sequence_lengths: a vector of lengths of each input sequence.
+/// output: If time_major is true, this is a 3-D tensor with the shape of
+///     [seq_length, batch_size, dir * num_units]. If time_major is false, the
+///     shape is [batch_size, seq_length, dir * num_units].
+/// output_h: The same shape has input_h.
+/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
+/// is_training: Indicates whether this operation is used for inferenece or
+///   training.
+/// time_major: Indicates whether the input/output format is time major or batch
+///     major.
+/// reserve_space: An opaque tensor that can be used in backprop calculation. It
+///   is only produced if is_training is true.
+@inlinable @inline(__always)
+public static func cudnnRNNV3<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  inputH: Tensor<T>,
+  inputC: Tensor<T>,
+  params: Tensor<T>,
+  sequenceLengths: Tensor<Int32>,
+  rnnMode: RnnMode = .lstm,
+  inputMode: InputMode = .linearInput,
+  direction: Direction = .unidirectional,
+  dropout: Double = 0,
+  seed: Int64 = 0,
+  seed2: Int64 = 0,
+  isTraining: Bool = true,
+  timeMajor: Bool = true
+) -> (output: Tensor<T>, outputH: Tensor<T>, outputC: Tensor<T>, reserveSpace: Tensor<T>, hostReserved: Tensor<Int8>) {
+  let op = TFE_Op("CudnnRNNV3")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("rnn_mode", rnnMode.cName)
+  op.setAttr("input_mode", inputMode.cName)
+  op.setAttr("direction", direction.cName)
+  op.setAttr("dropout", dropout)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("is_training", isTraining)
+  op.setAttr("time_major", timeMajor)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputH)
+  let _ = op.addInput(inputC)
+  let _ = op.addInput(params)
+  let _ = op.addInput(sequenceLengths)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Compute the cumulative product of the tensor `x` along `axis`.
+///
+/// By default, this op performs an inclusive cumprod, which means that the first
+/// element of the input is identical to the first element of the output:
+///
+/// ```python
+/// tf.cumprod([a, b, c])  # => [a, a * b, a * b * c]
+/// ```
+///
+/// By setting the `exclusive` kwarg to `True`, an exclusive cumprod is
+/// performed instead:
+///
+/// ```python
+/// tf.cumprod([a, b, c], exclusive=True)  # => [1, a, a * b]
+/// ```
+///
+/// By setting the `reverse` kwarg to `True`, the cumprod is performed in the
+/// opposite direction:
+///
+/// ```python
+/// tf.cumprod([a, b, c], reverse=True)  # => [a * b * c, b * c, c]
+/// ```
+///
+/// This is more efficient than using separate `tf.reverse` ops.
+///
+/// The `reverse` and `exclusive` kwargs can also be combined:
+///
+/// ```python
+/// tf.cumprod([a, b, c], exclusive=True, reverse=True)  # => [b * c, c, 1]
+/// ```
+///
+/// - Parameters:
+///   - x: A `Tensor`. Must be one of the following types: `float32`, `float64`,
+///     `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,
+///     `complex128`, `qint8`, `quint8`, `qint32`, `half`.
+///   - axis: A `Tensor` of type `int32` (default: 0). Must be in the range
+///     `[-rank(x), rank(x))`.
+///
+/// - Attrs:
+///   - exclusive: If `True`, perform exclusive cumprod.
+///   - reverse: A `bool` (default: False).
+@inlinable @inline(__always)
+public static func cumprod<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  _ x: Tensor<T>,
+  axis: Tensor<Tidx>,
+  exclusive: Bool = false,
+  reverse: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("Cumprod")
+  op.setAttr("exclusive", exclusive)
+  op.setAttr("reverse", reverse)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(axis)
+  return op.execute(Int(1))
+}
+
+/// Compute the cumulative sum of the tensor `x` along `axis`.
+///
+/// By default, this op performs an inclusive cumsum, which means that the first
+/// element of the input is identical to the first element of the output:
+///
+/// ```python
+/// tf.cumsum([a, b, c])  # => [a, a + b, a + b + c]
+/// ```
+///
+/// By setting the `exclusive` kwarg to `True`, an exclusive cumsum is
+/// performed instead:
+///
+/// ```python
+/// tf.cumsum([a, b, c], exclusive=True)  # => [0, a, a + b]
+/// ```
+///
+/// By setting the `reverse` kwarg to `True`, the cumsum is performed in the
+/// opposite direction:
+///
+/// ```python
+/// tf.cumsum([a, b, c], reverse=True)  # => [a + b + c, b + c, c]
+/// ```
+///
+/// This is more efficient than using separate `tf.reverse` ops.
+///
+/// The `reverse` and `exclusive` kwargs can also be combined:
+///
+/// ```python
+/// tf.cumsum([a, b, c], exclusive=True, reverse=True)  # => [b + c, c, 0]
+/// ```
+///
+/// - Parameters:
+///   - x: A `Tensor`. Must be one of the following types: `float32`, `float64`,
+///     `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,
+///     `complex128`, `qint8`, `quint8`, `qint32`, `half`.
+///   - axis: A `Tensor` of type `int32` (default: 0). Must be in the range
+///     `[-rank(x), rank(x))`.
+///
+/// - Attrs:
+///   - exclusive: If `True`, perform exclusive cumsum.
+///   - reverse: A `bool` (default: False).
+@inlinable @inline(__always)
+public static func cumsum<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  _ x: Tensor<T>,
+  axis: Tensor<Tidx>,
+  exclusive: Bool = false,
+  reverse: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("Cumsum")
+  op.setAttr("exclusive", exclusive)
+  op.setAttr("reverse", reverse)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(axis)
+  return op.execute(Int(1))
+}
+
+/// Returns the dimension index in the destination data format given the one in
+///
+/// the source data format.
+///
+/// - Parameter x: A Tensor with each element as a dimension index in source data format.
+///   Must be in the range [-4, 4).
+///
+/// - Attrs:
+///   - src_format: source data format.
+///   - dst_format: destination data format.
+///
+/// - Output y: A Tensor with each element as a dimension index in destination data format.
+@inlinable @inline(__always)
+public static func dataFormatDimMap<T: BinaryInteger & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  srcFormat: String = "NHWC",
+  dstFormat: String = "NCHW"
+) -> Tensor<T> {
+  let op = TFE_Op("DataFormatDimMap")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("src_format", srcFormat)
+  op.setAttr("dst_format", dstFormat)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns the permuted vector/tensor in the destination data format given the
+///
+/// one in the source data format.
+///
+/// - Parameter x: Vector of size 4 or Tensor of shape (4, 2) in source data format.
+///
+/// - Attrs:
+///   - src_format: source data format.
+///   - dst_format: destination data format.
+///
+/// - Output y: Vector of size 4 or Tensor of shape (4, 2) in destination data format.
+@inlinable @inline(__always)
+public static func dataFormatVecPermute<T: BinaryInteger & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  srcFormat: String = "NHWC",
+  dstFormat: String = "NCHW"
+) -> Tensor<T> {
+  let op = TFE_Op("DataFormatVecPermute")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("src_format", srcFormat)
+  op.setAttr("dst_format", dstFormat)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns a serialized GraphDef representing `input_dataset`.
+///
+/// Returns a graph representation for `input_dataset`.
+///
+/// - Parameter input_dataset: A variant tensor representing the dataset to return the graph representation for.
+///
+/// - Output graph: The graph representation of the dataset (as serialized GraphDef).
+@inlinable @inline(__always)
+public static func datasetToGraph(
+  inputDataset: VariantHandle
+) -> StringTensor {
+  let op = TFE_Op("DatasetToGraph")
+  let _ = op.addInput(inputDataset)
+  return op.execute(Int(1))
+}
+
+/// Outputs the single element from the given dataset.
+///
+/// - Parameter dataset: A handle to a dataset that contains a single element.
+///
+/// - Output components: The components of the single element of `input`.
+@inlinable @inline(__always)
+public static func datasetToSingleElement<OutputTypes: TensorGroup>(
+  dataset: VariantHandle,
+  outputShapes: [TensorShape?]
+) -> OutputTypes {
+  let op = TFE_Op("DatasetToSingleElement")
+  op.setAttr("output_types", OutputTypes._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(dataset)
+  return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Identity op for gradient debugging.
+///
+/// This op is hidden from public in Python. It is used by TensorFlow Debugger to
+/// register gradient tensors for gradient debugging.
+/// This op operates on non-reference-type tensors.
+@inlinable @inline(__always)
+public static func debugGradientIdentity<T: TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("DebugGradientIdentity")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Debug Identity Op.
+///
+/// Provides an identity mapping of the non-Ref type input tensor for debugging.
+///
+/// - Parameter input: Input tensor, non-Reference type.
+///
+/// - Attrs:
+///   - tensor_name: Name of the input tensor.
+///   - debug_urls: List of URLs to debug targets, e.g.,
+///     file:///foo/tfdbg_dump, grpc:://localhost:11011
+///   - gated_grpc: Whether this op will be gated. If any of the debug_urls of this
+///     debug node is of the grpc:// scheme, when the value of this attribute is set
+///     to True, the data will not actually be sent via the grpc stream unless this
+///     debug op has been enabled at the debug_url. If all of the debug_urls of this
+///     debug node are of the grpc:// scheme and the debug op is enabled at none of
+///     them, the output will be an empty Tensor.
+///
+/// - Output output: Output tensor that equals the input tensor.
+@inlinable @inline(__always)
+public static func debugIdentity<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  deviceName: String,
+  tensorName: String,
+  debugUrls: [String],
+  gatedGrpc: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("DebugIdentity")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("device_name", deviceName)
+  op.setAttr("tensor_name", tensorName)
+  op.setAttr("debug_urls", debugUrls)
+  op.setAttr("gated_grpc", gatedGrpc)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Debug NaN Value Counter Op
+///
+/// Counts number of NaNs in the input tensor, for debugging.
+///
+/// - Parameter input: Input tensor, non-Reference type.
+///
+/// - Attrs:
+///   - tensor_name: Name of the input tensor.
+///   - debug_urls: List of URLs to debug targets, e.g.,
+///     file:///foo/tfdbg_dump, grpc:://localhost:11011.
+///   - gated_grpc: Whether this op will be gated. If any of the debug_urls of this
+///     debug node is of the grpc:// scheme, when the value of this attribute is set
+///     to True, the data will not actually be sent via the grpc stream unless this
+///     debug op has been enabled at the debug_url. If all of the debug_urls of this
+///     debug node are of the grpc:// scheme and the debug op is enabled at none of
+///     them, the output will be an empty Tensor.
+///
+/// - Output output: An integer output tensor that is the number of NaNs in the input.
+@inlinable @inline(__always)
+public static func debugNanCount<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  deviceName: String,
+  tensorName: String,
+  debugUrls: [String],
+  gatedGrpc: Bool = false
+) -> Tensor<Int64> {
+  let op = TFE_Op("DebugNanCount")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("device_name", deviceName)
+  op.setAttr("tensor_name", tensorName)
+  op.setAttr("debug_urls", debugUrls)
+  op.setAttr("gated_grpc", gatedGrpc)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Debug Numeric Summary Op.
+///
+/// Provide a basic summary of numeric value types, range and distribution.
+///
+/// - Parameter input: Input tensor, non-Reference type, float or double.
+///
+/// - Attrs:
+///   - tensor_name: Name of the input tensor.
+///   - debug_urls: List of URLs to debug targets, e.g.,
+///     file:///foo/tfdbg_dump, grpc:://localhost:11011
+///   - lower_bound: (float) The lower bound <= which values will be included in the
+///     generalized -inf count. Default: -inf.
+///   - upper_bound: (float) The upper bound >= which values will be included in the
+///     generalized +inf count. Default: +inf.
+///   - mute_if_healthy: (bool) Do not send data to the debug URLs unless at least one
+///     of elements [2], [3] and [7] (i.e., the nan count and the generalized -inf and
+///     inf counts) is non-zero.
+///   - gated_grpc: Whether this op will be gated. If any of the debug_urls of this
+///     debug node is of the grpc:// scheme, when the value of this attribute is set
+///     to True, the data will not actually be sent via the grpc stream unless this
+///     debug op has been enabled at the debug_url. If all of the debug_urls of this
+///     debug node are of the grpc:// scheme and the debug op is enabled at none of
+///     them, the output will be an empty Tensor.
+///
+/// - Output output: A double tensor of shape [14 + nDimensions], where nDimensions is the
+///     the number of dimensions of the tensor's shape. The elements of output are:
+///     [0]: is initialized (1.0) or not (0.0).
+///     [1]: total number of elements
+///     [2]: NaN element count
+///     [3]: generalized -inf count: elements <= lower_bound. lower_bound is -inf by
+///       default.
+///     [4]: negative element count (excluding -inf), if lower_bound is the default
+///       -inf. Otherwise, this is the count of elements > lower_bound and < 0.
+///     [5]: zero element count
+///     [6]: positive element count (excluding +inf), if upper_bound is the default
+///       -inf. Otherwise, this is the count of elements < upper_bound and > 0.
+///     [7]: generalized +inf count, elements >= upper_bound. upper_bound is +inf by
+///       default.
+///   Output elements [1:8] are all zero, if the tensor is uninitialized.
+///     [8]: minimum of all non-inf and non-NaN elements.
+///          If uninitialized or no such element exists: +inf.
+///     [9]: maximum of all non-inf and non-NaN elements.
+///          If uninitialized or no such element exists: -inf.
+///     [10]: mean of all non-inf and non-NaN elements.
+///           If uninitialized or no such element exists: NaN.
+///     [11]: variance of all non-inf and non-NaN elements.
+///           If uninitialized or no such element exists: NaN.
+///     [12]: Data type of the tensor encoded as an enum integer. See the DataType
+///           proto for more details.
+///     [13]: Number of dimensions of the tensor (ndims).
+///     [14+]: Sizes of the dimensions.
+@inlinable @inline(__always)
+public static func debugNumericSummary<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  deviceName: String,
+  tensorName: String,
+  debugUrls: [String],
+  lowerBound: Double = -Double.infinity,
+  upperBound: Double = Double.infinity,
+  muteIfHealthy: Bool = false,
+  gatedGrpc: Bool = false
+) -> Tensor<Double> {
+  let op = TFE_Op("DebugNumericSummary")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("device_name", deviceName)
+  op.setAttr("tensor_name", tensorName)
+  op.setAttr("debug_urls", debugUrls)
+  op.setAttr("lower_bound", lowerBound)
+  op.setAttr("upper_bound", upperBound)
+  op.setAttr("mute_if_healthy", muteIfHealthy)
+  op.setAttr("gated_grpc", gatedGrpc)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Decode and Crop a JPEG-encoded image to a uint8 tensor.
+///
+/// The attr `channels` indicates the desired number of color channels for the
+/// decoded image.
+///
+/// Accepted values are:
+///
+/// *   0: Use the number of channels in the JPEG-encoded image.
+/// *   1: output a grayscale image.
+/// *   3: output an RGB image.
+///
+/// If needed, the JPEG-encoded image is transformed to match the requested number
+/// of color channels.
+///
+/// The attr `ratio` allows downscaling the image by an integer factor during
+/// decoding.  Allowed values are: 1, 2, 4, and 8.  This is much faster than
+/// downscaling the image later.
+///
+///
+/// It is equivalent to a combination of decode and crop, but much faster by only
+/// decoding partial jpeg image.
+///
+/// - Parameters:
+///   - contents: 0-D.  The JPEG-encoded image.
+///   - crop_window: 1-D.  The crop window: [crop_y, crop_x, crop_height, crop_width].
+///
+/// - Attrs:
+///   - channels: Number of color channels for the decoded image.
+///   - ratio: Downscaling ratio.
+///   - fancy_upscaling: If true use a slower but nicer upscaling of the
+///     chroma planes (yuv420/422 only).
+///   - try_recover_truncated: If true try to recover an image from truncated input.
+///   - acceptable_fraction: The minimum required fraction of lines before a truncated
+///     input is accepted.
+///   - dct_method: string specifying a hint about the algorithm used for
+///     decompression.  Defaults to "" which maps to a system-specific
+///     default.  Currently valid values are ["INTEGER_FAST",
+///     "INTEGER_ACCURATE"].  The hint may be ignored (e.g., the internal
+///     jpeg library changes to a version that does not have that specific
+///     option.)
+///
+/// - Output image: 3-D with shape `[height, width, channels]`..
+@inlinable @inline(__always)
+public static func decodeAndCropJpeg(
+  contents: StringTensor,
+  cropWindow: Tensor<Int32>,
+  channels: Int64 = 0,
+  ratio: Int64 = 1,
+  fancyUpscaling: Bool = true,
+  tryRecoverTruncated: Bool = false,
+  acceptableFraction: Double = 1,
+  dctMethod: String
+) -> Tensor<UInt8> {
+  let op = TFE_Op("DecodeAndCropJpeg")
+  op.setAttr("channels", channels)
+  op.setAttr("ratio", ratio)
+  op.setAttr("fancy_upscaling", fancyUpscaling)
+  op.setAttr("try_recover_truncated", tryRecoverTruncated)
+  op.setAttr("acceptable_fraction", acceptableFraction)
+  op.setAttr("dct_method", dctMethod)
+  let _ = op.addInput(contents)
+  let _ = op.addInput(cropWindow)
+  return op.execute(Int(1))
+}
+
+/// Decode web-safe base64-encoded strings.
+///
+/// Input may or may not have padding at the end. See EncodeBase64 for padding.
+/// Web-safe means that input must use - and _ instead of + and /.
+///
+/// - Parameter input: Base64 strings to decode.
+///
+/// - Output output: Decoded strings.
+@inlinable @inline(__always)
+public static func decodeBase64(
+  _ input: StringTensor
+) -> StringTensor {
+  let op = TFE_Op("DecodeBase64")
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Decode the first frame of a BMP-encoded image to a uint8 tensor.
+///
+/// The attr `channels` indicates the desired number of color channels for the
+/// decoded image.
+///
+/// Accepted values are:
+///
+/// *   0: Use the number of channels in the BMP-encoded image.
+/// *   3: output an RGB image.
+/// *   4: output an RGBA image.
+///
+/// - Parameter contents: 0-D.  The BMP-encoded image.
+///
+/// - Output image: 3-D with shape `[height, width, channels]`. RGB order
+@inlinable @inline(__always)
+public static func decodeBmp(
+  contents: StringTensor,
+  channels: Int64 = 0
+) -> Tensor<UInt8> {
+  let op = TFE_Op("DecodeBmp")
+  op.setAttr("channels", channels)
+  let _ = op.addInput(contents)
+  return op.execute(Int(1))
+}
+
+/// Convert CSV records to tensors. Each column maps to one tensor.
+///
+/// RFC 4180 format is expected for the CSV records.
+/// (https://tools.ietf.org/html/rfc4180)
+/// Note that we allow leading and trailing spaces with int or float field.
+///
+/// - Parameters:
+///   - records: Each string is a record/row in the csv and all records should have
+///     the same format.
+///   - record_defaults: One tensor per column of the input record, with either a
+///     scalar default value for that column or an empty vector if the column is
+///     required.
+///
+/// - Attrs:
+///   - field_delim: char delimiter to separate fields in a record.
+///   - use_quote_delim: If false, treats double quotation marks as regular
+///     characters inside of the string fields (ignoring RFC 4180, Section 2,
+///     Bullet 5).
+///   - na_value: Additional string to recognize as NA/NaN.
+///
+/// - Output output: Each tensor will have the same shape as records.
+@inlinable @inline(__always)
+public static func decodeCSV<OutType: TensorArrayProtocol>(
+  records: StringTensor,
+  recordDefaults: OutType,
+  fieldDelim: String = ",",
+  useQuoteDelim: Bool = true,
+  naValue: String,
+  selectCols: [Int32]
+) -> OutType {
+  let op = TFE_Op("DecodeCSV")
+  op.setAttr("OUT_TYPE", recordDefaults._typeList)
+  op.setAttr("field_delim", fieldDelim)
+  op.setAttr("use_quote_delim", useQuoteDelim)
+  op.setAttr("na_value", naValue)
+  op.setAttr("select_cols", selectCols)
+  let _ = op.addInput(records)
+  let _ = op.addInputList(recordDefaults)
+  return op.execute(Int(recordDefaults._typeList.count))
+}
+
+/// Decompress strings.
+///
+/// This op decompresses each element of the `bytes` input `Tensor`, which
+/// is assumed to be compressed using the given `compression_type`.
+///
+/// The `output` is a string `Tensor` of the same shape as `bytes`,
+/// each element containing the decompressed data from the corresponding
+/// element in `bytes`.
+///
+/// - Parameter bytes: A Tensor of string which is compressed.
+///
+/// - Attr compression_type: A scalar containing either (i) the empty string (no
+///   compression), (ii) "ZLIB", or (iii) "GZIP".
+///
+/// - Output output: A Tensor with the same shape as input `bytes`, uncompressed
+///   from bytes.
+@inlinable @inline(__always)
+public static func decodeCompressed(
+  bytes: StringTensor,
+  compressionType: String
+) -> StringTensor {
+  let op = TFE_Op("DecodeCompressed")
+  op.setAttr("compression_type", compressionType)
+  let _ = op.addInput(bytes)
+  return op.execute(Int(1))
+}
+
+/// Decode the frame(s) of a GIF-encoded image to a uint8 tensor.
+///
+/// GIF images with frame or transparency compression are not supported.
+/// On Linux and MacOS systems, convert animated GIFs from compressed to
+/// uncompressed by running:
+///
+///     convert $src.gif -coalesce $dst.gif
+///
+/// This op also supports decoding JPEGs and PNGs, though it is cleaner to use
+/// `tf.image.decode_image`.
+///
+/// - Parameter contents: 0-D.  The GIF-encoded image.
+///
+/// - Output image: 4-D with shape `[num_frames, height, width, 3]`. RGB channel order.
+@inlinable @inline(__always)
+public static func decodeGif(
+  contents: StringTensor
+) -> Tensor<UInt8> {
+  let op = TFE_Op("DecodeGif")
+  let _ = op.addInput(contents)
+  return op.execute(Int(1))
+}
+
+/// Convert JSON-encoded Example records to binary protocol buffer strings.
+///
+/// This op translates a tensor containing Example records, encoded using
+/// the [standard JSON
+/// mapping](https://developers.google.com/protocol-buffers/docs/proto3#json),
+/// into a tensor containing the same records encoded as binary protocol
+/// buffers. The resulting tensor can then be fed to any of the other
+/// Example-parsing ops.
+///
+/// - Parameter json_examples: Each string is a JSON object serialized according to the JSON
+///   mapping of the Example proto.
+///
+/// - Output binary_examples: Each string is a binary Example protocol buffer corresponding
+///   to the respective element of `json_examples`.
+@inlinable @inline(__always)
+public static func decodeJSONExample(
+  jsonExamples: StringTensor
+) -> StringTensor {
+  let op = TFE_Op("DecodeJSONExample")
+  let _ = op.addInput(jsonExamples)
+  return op.execute(Int(1))
+}
+
+/// Decode a JPEG-encoded image to a uint8 tensor.
+///
+/// The attr `channels` indicates the desired number of color channels for the
+/// decoded image.
+///
+/// Accepted values are:
+///
+/// *   0: Use the number of channels in the JPEG-encoded image.
+/// *   1: output a grayscale image.
+/// *   3: output an RGB image.
+///
+/// If needed, the JPEG-encoded image is transformed to match the requested number
+/// of color channels.
+///
+/// The attr `ratio` allows downscaling the image by an integer factor during
+/// decoding.  Allowed values are: 1, 2, 4, and 8.  This is much faster than
+/// downscaling the image later.
+///
+///
+/// This op also supports decoding PNGs and non-animated GIFs since the interface is
+/// the same, though it is cleaner to use `tf.image.decode_image`.
+///
+/// - Parameter contents: 0-D.  The JPEG-encoded image.
+///
+/// - Attrs:
+///   - channels: Number of color channels for the decoded image.
+///   - ratio: Downscaling ratio.
+///   - fancy_upscaling: If true use a slower but nicer upscaling of the
+///     chroma planes (yuv420/422 only).
+///   - try_recover_truncated: If true try to recover an image from truncated input.
+///   - acceptable_fraction: The minimum required fraction of lines before a truncated
+///     input is accepted.
+///   - dct_method: string specifying a hint about the algorithm used for
+///     decompression.  Defaults to "" which maps to a system-specific
+///     default.  Currently valid values are ["INTEGER_FAST",
+///     "INTEGER_ACCURATE"].  The hint may be ignored (e.g., the internal
+///     jpeg library changes to a version that does not have that specific
+///     option.)
+///
+/// - Output image: 3-D with shape `[height, width, channels]`..
+@inlinable @inline(__always)
+public static func decodeJpeg(
+  contents: StringTensor,
+  channels: Int64 = 0,
+  ratio: Int64 = 1,
+  fancyUpscaling: Bool = true,
+  tryRecoverTruncated: Bool = false,
+  acceptableFraction: Double = 1,
+  dctMethod: String
+) -> Tensor<UInt8> {
+  let op = TFE_Op("DecodeJpeg")
+  op.setAttr("channels", channels)
+  op.setAttr("ratio", ratio)
+  op.setAttr("fancy_upscaling", fancyUpscaling)
+  op.setAttr("try_recover_truncated", tryRecoverTruncated)
+  op.setAttr("acceptable_fraction", acceptableFraction)
+  op.setAttr("dct_method", dctMethod)
+  let _ = op.addInput(contents)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func decodePaddedRaw<OutType: Numeric & TensorFlowScalar>(
+  inputBytes: StringTensor,
+  fixedLength: Tensor<Int32>,
+  littleEndian: Bool = true
+) -> Tensor<OutType> {
+  let op = TFE_Op("DecodePaddedRaw")
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("little_endian", littleEndian)
+  let _ = op.addInput(inputBytes)
+  let _ = op.addInput(fixedLength)
+  return op.execute(Int(1))
+}
+
+/// Decode a PNG-encoded image to a uint8 or uint16 tensor.
+///
+/// The attr `channels` indicates the desired number of color channels for the
+/// decoded image.
+///
+/// Accepted values are:
+///
+/// *   0: Use the number of channels in the PNG-encoded image.
+/// *   1: output a grayscale image.
+/// *   3: output an RGB image.
+/// *   4: output an RGBA image.
+///
+/// If needed, the PNG-encoded image is transformed to match the requested number
+/// of color channels.
+///
+/// This op also supports decoding JPEGs and non-animated GIFs since the interface
+/// is the same, though it is cleaner to use `tf.image.decode_image`.
+///
+/// - Parameter contents: 0-D.  The PNG-encoded image.
+///
+/// - Attr channels: Number of color channels for the decoded image.
+///
+/// - Output image: 3-D with shape `[height, width, channels]`.
+@inlinable @inline(__always)
+public static func decodePng<Dtype: UnsignedInteger & TensorFlowScalar>(
+  contents: StringTensor,
+  channels: Int64 = 0
+) -> Tensor<Dtype> {
+  let op = TFE_Op("DecodePng")
+  op.setAttr("channels", channels)
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(contents)
+  return op.execute(Int(1))
+}
+
+/// The op extracts fields from a serialized protocol buffers message into tensors.
+///
+/// The `decode_proto` op extracts fields from a serialized protocol buffers
+/// message into tensors.  The fields in `field_names` are decoded and converted
+/// to the corresponding `output_types` if possible.
+///
+/// A `message_type` name must be provided to give context for the field
+/// names. The actual message descriptor can be looked up either in the
+/// linked-in descriptor pool or a filename provided by the caller using
+/// the `descriptor_source` attribute.
+///
+/// Each output tensor is a dense tensor. This means that it is padded to
+/// hold the largest number of repeated elements seen in the input
+/// minibatch. (The shape is also padded by one to prevent zero-sized
+/// dimensions). The actual repeat counts for each example in the
+/// minibatch can be found in the `sizes` output. In many cases the output
+/// of `decode_proto` is fed immediately into tf.squeeze if missing values
+/// are not a concern. When using tf.squeeze, always pass the squeeze
+/// dimension explicitly to avoid surprises.
+///
+/// For the most part, the mapping between Proto field types and
+/// TensorFlow dtypes is straightforward. However, there are a few
+/// special cases:
+///
+/// - A proto field that contains a submessage or group can only be converted
+/// to `DT_STRING` (the serialized submessage). This is to reduce the
+/// complexity of the API. The resulting string can be used as input
+/// to another instance of the decode_proto op.
+///
+/// - TensorFlow lacks support for unsigned integers. The ops represent uint64
+/// types as a `DT_INT64` with the same twos-complement bit pattern
+/// (the obvious way). Unsigned int32 values can be represented exactly by
+/// specifying type `DT_INT64`, or using twos-complement if the caller
+/// specifies `DT_INT32` in the `output_types` attribute.
+///
+/// The `descriptor_source` attribute selects a source of protocol
+/// descriptors to consult when looking up `message_type`. This may be a
+/// filename containing a serialized `FileDescriptorSet` message,
+/// or the special value `local://`, in which case only descriptors linked
+/// into the code will be searched; the filename can be on any filesystem
+/// accessible to TensorFlow.
+///
+/// You can build a `descriptor_source` file using the `--descriptor_set_out`
+/// and `--include_imports` options to the protocol compiler `protoc`.
+///
+/// The `local://` database only covers descriptors linked into the
+/// code via C++ libraries, not Python imports. You can link in a proto descriptor
+/// by creating a cc_library target with alwayslink=1.
+///
+/// Both binary and text proto serializations are supported, and can be
+/// chosen using the `format` attribute.
+///
+/// - Parameter bytes: Tensor of serialized protos with shape `batch_shape`.
+///
+/// - Attrs:
+///   - message_type: Name of the proto message type to decode.
+///   - field_names: List of strings containing proto field names. An extension field can be decoded
+///     by using its full name, e.g. EXT_PACKAGE.EXT_FIELD_NAME.
+///   - output_types: List of TF types to use for the respective field in field_names.
+///   - descriptor_source: Either the special value `local://` or a path to a file containing
+///     a serialized `FileDescriptorSet`.
+///   - message_format: Either `binary` or `text`.
+///   - sanitize: Whether to sanitize the result or not.
+///
+/// - Outputs:
+///   - sizes: Tensor of int32 with shape `[batch_shape, len(field_names)]`.
+///     Each entry is the number of values found for the corresponding field.
+///     Optional fields may have 0 or 1 values.
+///   - values: List of tensors containing values for the corresponding field.
+///     `values[i]` has datatype `output_types[i]`
+///     and shape `[batch_shape, max(sizes[...,i])]`.
+@inlinable @inline(__always)
+public static func decodeProtoV2<OutputTypes: TensorGroup>(
+  bytes: StringTensor,
+  messageType: String,
+  fieldNames: [String],
+  descriptorSource: String = "local://",
+  messageFormat: String = "binary",
+  sanitize: Bool = false
+) -> (sizes: Tensor<Int32>, values: OutputTypes) {
+  let op = TFE_Op("DecodeProtoV2")
+  op.setAttr("message_type", messageType)
+  op.setAttr("field_names", fieldNames)
+  op.setAttr("output_types", OutputTypes._typeList)
+  op.setAttr("descriptor_source", descriptorSource)
+  op.setAttr("message_format", messageFormat)
+  op.setAttr("sanitize", sanitize)
+  let _ = op.addInput(bytes)
+  return op.execute(Int(1), Int(OutputTypes._typeList.count))
+}
+
+/// Reinterpret the bytes of a string as a vector of numbers.
+///
+/// - Parameter bytes: All the elements must have the same length.
+///
+/// - Attr little_endian: Whether the input `bytes` are in little-endian order.
+///   Ignored for `out_type` values that are stored in a single byte like
+///   `uint8`.
+///
+/// - Output output: A Tensor with one more dimension than the input `bytes`.  The
+///   added dimension will have size equal to the length of the elements
+///   of `bytes` divided by the number of bytes to represent `out_type`.
+@inlinable @inline(__always)
+public static func decodeRaw<OutType: TensorFlowScalar>(
+  bytes: StringTensor,
+  littleEndian: Bool = true
+) -> Tensor<OutType> {
+  let op = TFE_Op("DecodeRaw")
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("little_endian", littleEndian)
+  let _ = op.addInput(bytes)
+  return op.execute(Int(1))
+}
+
+/// Decode a 16-bit PCM WAV file to a float tensor.
+///
+/// The -32768 to 32767 signed 16-bit values will be scaled to -1.0 to 1.0 in float.
+///
+/// When desired_channels is set, if the input contains fewer channels than this
+/// then the last channel will be duplicated to give the requested number, else if
+/// the input has more channels than requested then the additional channels will be
+/// ignored.
+///
+/// If desired_samples is set, then the audio will be cropped or padded with zeroes
+/// to the requested length.
+///
+/// The first output contains a Tensor with the content of the audio samples. The
+/// lowest dimension will be the number of channels, and the second will be the
+/// number of samples. For example, a ten-sample-long stereo WAV file should give an
+/// output shape of [10, 2].
+///
+/// - Parameter contents: The WAV-encoded audio, usually from a file.
+///
+/// - Attrs:
+///   - desired_channels: Number of sample channels wanted.
+///   - desired_samples: Length of audio requested.
+///
+/// - Outputs:
+///   - audio: 2-D with shape `[length, channels]`.
+///   - sample_rate: Scalar holding the sample rate found in the WAV header.
+@inlinable @inline(__always)
+public static func decodeWav(
+  contents: StringTensor,
+  desiredChannels: Int64 = -1,
+  desiredSamples: Int64 = -1
+) -> (audio: Tensor<Float>, sampleRate: Tensor<Int32>) {
+  let op = TFE_Op("DecodeWav")
+  op.setAttr("desired_channels", desiredChannels)
+  op.setAttr("desired_samples", desiredSamples)
+  let _ = op.addInput(contents)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Makes a copy of `x`.
+///
+/// - Parameter x: The source tensor of type `T`.
+///
+/// - Output y:     y: A `Tensor` of type `T`. A copy of `x`. Guaranteed that `y`
+///         is not an alias of `x`.
+@inlinable @inline(__always)
+public static func deepCopy<T: TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("DeepCopy")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// A container for an iterator resource.
+///
+/// - Parameters:
+///   - handle: A handle to the iterator to delete.
+///   - deleter: A variant deleter.
+@inlinable @inline(__always)
+public static func deleteIterator(
+  handle: ResourceHandle,
+  deleter: VariantHandle
+) {
+  let op = TFE_Op("DeleteIterator")
+  let _ = op.addInput(handle)
+  let _ = op.addInput(deleter)
+  op.execute()
+}
+
+/// Delete the tensor specified by its handle in the session.
+///
+/// - Parameter handle: The handle for a tensor stored in the session state.
+@inlinable @inline(__always)
+public static func deleteSessionTensor(
+  handle: StringTensor
+) {
+  let op = TFE_Op("DeleteSessionTensor")
+  let _ = op.addInput(handle)
+  op.execute()
+}
+
+/// Applies set operation along last dimension of 2 `Tensor` inputs.
+///
+/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+///
+/// Output `result` is a `SparseTensor` represented by `result_indices`,
+/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+/// dimension contains the result of `set_operation` applied to the corresponding
+/// `[0...n-1]` dimension of `set`.
+///
+/// - Parameters:
+///   - set1: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
+///     Dimension `n` contains values in a set, duplicates are allowed but ignored.
+///   - set2: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set1`.
+///     Dimension `n` contains values in a set, duplicates are allowed but ignored.
+///
+/// - Outputs:
+///   - result_indices: 2D indices of a `SparseTensor`.
+///   - result_values: 1D values of a `SparseTensor`.
+///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+///     is the max result set size across all `0...n-1` dimensions.
+@inlinable @inline(__always)
+public static func denseToDenseSetOperation<T: BinaryInteger & TensorFlowScalar>(
+  set1: Tensor<T>,
+  set2: Tensor<T>,
+  setOperation: String,
+  validateIndices: Bool = true
+) -> (resultIndices: Tensor<Int64>, resultValues: Tensor<T>, resultShape: Tensor<Int64>) {
+  let op = TFE_Op("DenseToDenseSetOperation")
+  op.setAttr("set_operation", setOperation)
+  op.setAttr("validate_indices", validateIndices)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(set1)
+  let _ = op.addInput(set2)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Applies set operation along last dimension of 2 `Tensor` inputs.
+///
+/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+///
+/// Output `result` is a `SparseTensor` represented by `result_indices`,
+/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+/// dimension contains the result of `set_operation` applied to the corresponding
+/// `[0...n-1]` dimension of `set`.
+///
+/// - Parameters:
+///   - set1: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
+///     Dimension `n` contains values in a set, duplicates are allowed but ignored.
+///   - set2: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set1`.
+///     Dimension `n` contains values in a set, duplicates are allowed but ignored.
+///
+/// - Outputs:
+///   - result_indices: 2D indices of a `SparseTensor`.
+///   - result_values: 1D values of a `SparseTensor`.
+///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+///     is the max result set size across all `0...n-1` dimensions.
+@inlinable @inline(__always)
+public static func denseToDenseSetOperation(
+  set1: StringTensor,
+  set2: StringTensor,
+  setOperation: String,
+  validateIndices: Bool = true
+) -> (resultIndices: Tensor<Int64>, resultValues: StringTensor, resultShape: Tensor<Int64>) {
+  let op = TFE_Op("DenseToDenseSetOperation")
+  op.setAttr("set_operation", setOperation)
+  op.setAttr("validate_indices", validateIndices)
+  op.setAttr("T", TensorDataType(TF_STRING))
+  let _ = op.addInput(set1)
+  let _ = op.addInput(set2)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Applies set operation along last dimension of `Tensor` and `SparseTensor`.
+///
+/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+///
+/// Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
+/// and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
+/// as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
+/// ignored.
+///
+/// If `validate_indices` is `True`, this op validates the order and range of `set2`
+/// indices.
+///
+/// Output `result` is a `SparseTensor` represented by `result_indices`,
+/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+/// dimension contains the result of `set_operation` applied to the corresponding
+/// `[0...n-1]` dimension of `set`.
+///
+/// - Parameters:
+///   - set1: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
+///     Dimension `n` contains values in a set, duplicates are allowed but ignored.
+///   - set2_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+///     order.
+///   - set2_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+///     order.
+///   - set2_shape: 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
+///     be the same as the 1st `n-1` dimensions of `set1`, `result_shape[n]` is the
+///     max set size across `n-1` dimensions.
+///
+/// - Outputs:
+///   - result_indices: 2D indices of a `SparseTensor`.
+///   - result_values: 1D values of a `SparseTensor`.
+///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+///     is the max result set size across all `0...n-1` dimensions.
+@inlinable @inline(__always)
+public static func denseToSparseSetOperation<T: BinaryInteger & TensorFlowScalar>(
+  set1: Tensor<T>,
+  set2Indices: Tensor<Int64>,
+  set2Values: Tensor<T>,
+  set2Shape: Tensor<Int64>,
+  setOperation: String,
+  validateIndices: Bool = true
+) -> (resultIndices: Tensor<Int64>, resultValues: Tensor<T>, resultShape: Tensor<Int64>) {
+  let op = TFE_Op("DenseToSparseSetOperation")
+  op.setAttr("set_operation", setOperation)
+  op.setAttr("validate_indices", validateIndices)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(set1)
+  let _ = op.addInput(set2Indices)
+  let _ = op.addInput(set2Values)
+  let _ = op.addInput(set2Shape)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Applies set operation along last dimension of `Tensor` and `SparseTensor`.
+///
+/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+///
+/// Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
+/// and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
+/// as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
+/// ignored.
+///
+/// If `validate_indices` is `True`, this op validates the order and range of `set2`
+/// indices.
+///
+/// Output `result` is a `SparseTensor` represented by `result_indices`,
+/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+/// dimension contains the result of `set_operation` applied to the corresponding
+/// `[0...n-1]` dimension of `set`.
+///
+/// - Parameters:
+///   - set1: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
+///     Dimension `n` contains values in a set, duplicates are allowed but ignored.
+///   - set2_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+///     order.
+///   - set2_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+///     order.
+///   - set2_shape: 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
+///     be the same as the 1st `n-1` dimensions of `set1`, `result_shape[n]` is the
+///     max set size across `n-1` dimensions.
+///
+/// - Outputs:
+///   - result_indices: 2D indices of a `SparseTensor`.
+///   - result_values: 1D values of a `SparseTensor`.
+///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+///     is the max result set size across all `0...n-1` dimensions.
+@inlinable @inline(__always)
+public static func denseToSparseSetOperation(
+  set1: StringTensor,
+  set2Indices: Tensor<Int64>,
+  set2Values: StringTensor,
+  set2Shape: Tensor<Int64>,
+  setOperation: String,
+  validateIndices: Bool = true
+) -> (resultIndices: Tensor<Int64>, resultValues: StringTensor, resultShape: Tensor<Int64>) {
+  let op = TFE_Op("DenseToSparseSetOperation")
+  op.setAttr("set_operation", setOperation)
+  op.setAttr("validate_indices", validateIndices)
+  op.setAttr("T", TensorDataType(TF_STRING))
+  let _ = op.addInput(set1)
+  let _ = op.addInput(set2Indices)
+  let _ = op.addInput(set2Values)
+  let _ = op.addInput(set2Shape)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// DepthToSpace for tensors of type T.
+///
+/// Rearranges data from depth into blocks of spatial data.
+/// This is the reverse transformation of SpaceToDepth. More specifically,
+/// this op outputs a copy of the input tensor where values from the `depth`
+/// dimension are moved in spatial blocks to the `height` and `width` dimensions.
+/// The attr `block_size` indicates the input block size and how the data is moved.
+///
+///   * Chunks of data of size `block_size * block_size` from depth are rearranged
+///     into non-overlapping blocks of size `block_size x block_size`
+///   * The width the output tensor is `input_depth * block_size`, whereas the
+///     height is `input_height * block_size`.
+///   * The Y, X coordinates within each block of the output image are determined
+///     by the high order component of the input channel index.
+///   * The depth of the input tensor must be divisible by
+///     `block_size * block_size`.
+///
+/// The `data_format` attr specifies the layout of the input and output tensors
+/// with the following options:
+///   "NHWC": `[ batch, height, width, channels ]`
+///   "NCHW": `[ batch, channels, height, width ]`
+///   "NCHW_VECT_C":
+///       `qint8 [ batch, channels / 4, height, width, 4 ]`
+///
+/// It is useful to consider the operation as transforming a 6-D Tensor.
+/// e.g. for data_format = NHWC,
+///      Each element in the input tensor can be specified via 6 coordinates,
+///      ordered by decreasing memory layout significance as:
+///      n,iY,iX,bY,bX,oC  (where n=batch index, iX, iY means X or Y coordinates
+///                         within the input image, bX, bY means coordinates
+///                         within the output block, oC means output channels).
+///      The output would be the input transposed to the following layout:
+///      n,iY,bY,iX,bX,oC
+///
+/// This operation is useful for resizing the activations between convolutions
+/// (but keeping all data), e.g. instead of pooling. It is also useful for training
+/// purely convolutional models.
+///
+/// For example, given an input of shape `[1, 1, 1, 4]`, data_format = "NHWC" and
+/// block_size = 2:
+///
+/// ```
+/// x = [[[[1, 2, 3, 4]]]]
+///
+/// ```
+///
+/// This operation will output a tensor of shape `[1, 2, 2, 1]`:
+///
+/// ```
+///    [[[[1], [2]],
+///      [[3], [4]]]]
+/// ```
+///
+/// Here, the input has a batch of 1 and each batch element has shape `[1, 1, 4]`,
+/// the corresponding output will have 2x2 elements and will have a depth of
+/// 1 channel (1 = `4 / (block_size * block_size)`).
+/// The output element shape is `[2, 2, 1]`.
+///
+/// For an input tensor with larger depth, here of shape `[1, 1, 1, 12]`, e.g.
+///
+/// ```
+/// x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
+/// ```
+///
+/// This operation, for block size of 2, will return the following tensor of shape
+/// `[1, 2, 2, 3]`
+///
+/// ```
+///    [[[[1, 2, 3], [4, 5, 6]],
+///      [[7, 8, 9], [10, 11, 12]]]]
+///
+/// ```
+///
+/// Similarly, for the following input of shape `[1 2 2 4]`, and a block size of 2:
+///
+/// ```
+/// x =  [[[[1, 2, 3, 4],
+///        [5, 6, 7, 8]],
+///       [[9, 10, 11, 12],
+///        [13, 14, 15, 16]]]]
+/// ```
+///
+/// the operator will return the following tensor of shape `[1 4 4 1]`:
+///
+/// ```
+/// x = [[[ [1],   [2],  [5],  [6]],
+///       [ [3],   [4],  [7],  [8]],
+///       [ [9],  [10], [13],  [14]],
+///       [ [11], [12], [15],  [16]]]]
+///
+/// ```
+///
+/// - Attr block_size: The size of the spatial block, same as in Space2Depth.
+@inlinable @inline(__always)
+public static func depthToSpace<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  blockSize: Int64,
+  dataFormat: DataFormat4 = .nhwc
+) -> Tensor<T> {
+  let op = TFE_Op("DepthToSpace")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("block_size", blockSize)
+  op.setAttr("data_format", dataFormat.cName)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Computes a 2-D depthwise convolution given 4-D `input` and `filter` tensors.
+///
+/// Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
+/// and a filter / kernel tensor of shape
+/// `[filter_height, filter_width, in_channels, channel_multiplier]`, containing
+/// `in_channels` convolutional filters of depth 1, `depthwise_conv2d` applies
+/// a different filter to each input channel (expanding from 1 channel to
+/// `channel_multiplier` channels for each), then concatenates the results
+/// together. Thus, the output has `in_channels * channel_multiplier` channels.
+///
+/// ```
+/// for k in 0..in_channels-1
+///   for q in 0..channel_multiplier-1
+///     output[b, i, j, k * channel_multiplier + q] =
+///       sum_{di, dj} input[b, strides[1] * i + di, strides[2] * j + dj, k] *
+///                         filter[di, dj, k, q]
+/// ```
+///
+/// Must have `strides[0] = strides[3] = 1`.  For the most common case of the same
+/// horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
+///
+/// - Attrs:
+///   - strides: 1-D of length 4.  The stride of the sliding window for each dimension
+///     of `input`.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, height, width, channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, channels, height, width].
+///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///     `input`. If set to k > 1, there will be k-1 skipped cells between each filter
+///     element on that dimension. The dimension order is determined by the value of
+///     `data_format`, see above for details. Dilations in the batch and depth
+///     dimensions must be 1.
+@inlinable @inline(__always)
+public static func depthwiseConv2dNative<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  filter: Tensor<T>,
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat = .nhwc,
+  dilations: [Int32] = [1, 1, 1, 1]
+) -> Tensor<T> {
+  let op = TFE_Op("DepthwiseConv2dNative")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradients of depthwise convolution with respect to the filter.
+///
+/// - Parameters:
+///   - input: 4-D with shape based on `data_format`.  For example, if
+///     `data_format` is 'NHWC' then `input` is a 4-D `[batch, in_height,
+///     in_width, in_channels]` tensor.
+///   - filter_sizes: An integer vector representing the tensor shape of `filter`,
+///     where `filter` is a 4-D
+///     `[filter_height, filter_width, in_channels, depthwise_multiplier]` tensor.
+///   - out_backprop: 4-D with shape  based on `data_format`.
+///     For example, if `data_format` is 'NHWC' then
+///     out_backprop shape is `[batch, out_height, out_width, out_channels]`.
+///     Gradients w.r.t. the output of the convolution.
+///
+/// - Attrs:
+///   - strides: The stride of the sliding window for each dimension of the input
+///     of the convolution.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, height, width, channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, channels, height, width].
+///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///     `input`. If set to k > 1, there will be k-1 skipped cells between each filter
+///     element on that dimension. The dimension order is determined by the value of
+///     `data_format`, see above for details. Dilations in the batch and depth
+///     dimensions must be 1.
+///
+/// - Output output: 4-D with shape
+///   `[filter_height, filter_width, in_channels, out_channels]`.  Gradient w.r.t.
+///   the `filter` input of the convolution.
+@inlinable @inline(__always)
+public static func depthwiseConv2dNativeBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  filterSizes: Tensor<Int32>,
+  outBackprop: Tensor<T>,
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat = .nhwc,
+  dilations: [Int32] = [1, 1, 1, 1]
+) -> Tensor<T> {
+  let op = TFE_Op("DepthwiseConv2dNativeBackpropFilter")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filterSizes)
+  let _ = op.addInput(outBackprop)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradients of depthwise convolution with respect to the input.
+///
+/// - Parameters:
+///   - input_sizes: An integer vector representing the shape of `input`, based
+///     on `data_format`.  For example, if `data_format` is 'NHWC' then
+///      `input` is a 4-D `[batch, height, width, channels]` tensor.
+///   - filter: 4-D with shape
+///     `[filter_height, filter_width, in_channels, depthwise_multiplier]`.
+///   - out_backprop: 4-D with shape  based on `data_format`.
+///     For example, if `data_format` is 'NHWC' then
+///     out_backprop shape is `[batch, out_height, out_width, out_channels]`.
+///     Gradients w.r.t. the output of the convolution.
+///
+/// - Attrs:
+///   - strides: The stride of the sliding window for each dimension of the input
+///     of the convolution.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, height, width, channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, channels, height, width].
+///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///     `input`. If set to k > 1, there will be k-1 skipped cells between each filter
+///     element on that dimension. The dimension order is determined by the value of
+///     `data_format`, see above for details. Dilations in the batch and depth
+///     dimensions must be 1.
+///
+/// - Output output: 4-D with shape according to `data_format`.  For example, if
+///   `data_format` is 'NHWC', output shape is `[batch, in_height,
+///   in_width, in_channels]`.  Gradient w.r.t. the input of the
+///   convolution.
+@inlinable @inline(__always)
+public static func depthwiseConv2dNativeBackpropInput<T: FloatingPoint & TensorFlowScalar>(
+  inputSizes: Tensor<Int32>,
+  filter: Tensor<T>,
+  outBackprop: Tensor<T>,
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat = .nhwc,
+  dilations: [Int32] = [1, 1, 1, 1]
+) -> Tensor<T> {
+  let op = TFE_Op("DepthwiseConv2dNativeBackpropInput")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(inputSizes)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(outBackprop)
+  return op.execute(Int(1))
+}
+
+/// Dequantize the 'input' tensor into a float Tensor.
+///
+/// [min_range, max_range] are scalar floats that specify the range for
+/// the 'input' data. The 'mode' attribute controls exactly which calculations are
+/// used to convert the float values to their quantized equivalents.
+///
+/// In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:
+///
+/// ```
+/// if T == qint8: in[i] += (range(T) + 1)/ 2.0
+/// out[i] = min_range + (in[i]* (max_range - min_range) / range(T))
+/// ```
+/// here `range(T) = numeric_limits<T>::max() - numeric_limits<T>::min()`
+///
+/// *MIN_COMBINED Mode Example*
+///
+/// If the input comes from a QuantizedRelu6, the output type is
+/// quint8 (range of 0-255) but the possible range of QuantizedRelu6 is
+/// 0-6.  The min_range and max_range values are therefore 0.0 and 6.0.
+/// Dequantize on quint8 will take each value, cast to float, and multiply
+/// by 6 / 255.
+/// Note that if quantizedtype is qint8, the operation will additionally add
+/// each value by 128 prior to casting.
+///
+/// If the mode is 'MIN_FIRST', then this approach is used:
+///
+/// ```c++
+/// num_discrete_values = 1 << (# of bits in T)
+/// range_adjust = num_discrete_values / (num_discrete_values - 1)
+/// range = (range_max - range_min) * range_adjust
+/// range_scale = range / num_discrete_values
+/// const double offset_input = static_cast<double>(input) - lowest_quantized;
+/// result = range_min + ((input - numeric_limits<T>::min()) * range_scale)
+/// ```
+///
+/// *SCALED mode Example*
+///
+/// `SCALED` mode matches the quantization approach used in
+/// `QuantizeAndDequantize{V2|V3}`.
+///
+/// If the mode is `SCALED`, we do not use the full range of the output type,
+/// choosing to elide the lowest possible value for symmetry (e.g., output range is
+/// -127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to
+/// 0.
+///
+/// We first find the range of values in our tensor. The
+/// range we use is always centered on 0, so we find m such that
+/// ```c++
+///   m = max(abs(input_min), abs(input_max))
+/// ```
+///
+/// Our input tensor range is then `[-m, m]`.
+///
+/// Next, we choose our fixed-point quantization buckets, `[min_fixed, max_fixed]`.
+/// If T is signed, this is
+/// ```
+///   num_bits = sizeof(T) * 8
+///   [min_fixed, max_fixed] =
+///       [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]
+/// ```
+///
+/// Otherwise, if T is unsigned, the fixed-point range is
+/// ```
+///   [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]
+/// ```
+///
+/// From this we compute our scaling factor, s:
+/// ```c++
+///   s = (2 * m) / (max_fixed - min_fixed)
+/// ```
+///
+/// Now we can dequantize the elements of our tensor:
+/// ```c++
+/// result = input * s
+/// ```
+///
+/// - Parameters:
+///   - min_range: The minimum scalar value possibly produced for the input.
+///   - max_range: The maximum scalar value possibly produced for the input.
+@inlinable @inline(__always)
+public static func dequantize<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  minRange: Tensor<Float>,
+  maxRange: Tensor<Float>,
+  mode: Mode = .minCombined
+) -> Tensor<Float> {
+  let op = TFE_Op("Dequantize")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("mode", mode.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(minRange)
+  let _ = op.addInput(maxRange)
+  return op.execute(Int(1))
+}
+
+/// Converts the given variant tensor to an iterator and stores it in the given resource.
+///
+/// - Parameters:
+///   - resource_handle: A handle to an iterator resource.
+///   - serialized: A variant tensor storing the state of the iterator contained in the
+///     resource.
+@inlinable @inline(__always)
+public static func deserializeIterator(
+  resourceHandle: ResourceHandle,
+  serialized: VariantHandle
+) {
+  let op = TFE_Op("DeserializeIterator")
+  let _ = op.addInput(resourceHandle)
+  let _ = op.addInput(serialized)
+  op.execute()
+}
+
+/// Deserialize and concatenate `SparseTensors` from a serialized minibatch.
+///
+/// The input `serialized_sparse` must be a string matrix of shape `[N x 3]` where
+/// `N` is the minibatch size and the rows correspond to packed outputs of
+/// `SerializeSparse`.  The ranks of the original `SparseTensor` objects
+/// must all match.  When the final `SparseTensor` is created, it has rank one
+/// higher than the ranks of the incoming `SparseTensor` objects
+/// (they have been concatenated along a new row dimension).
+///
+/// The output `SparseTensor` object's shape values for all dimensions but the
+/// first are the max across the input `SparseTensor` objects' shape values
+/// for the corresponding dimensions.  Its first shape value is `N`, the minibatch
+/// size.
+///
+/// The input `SparseTensor` objects' indices are assumed ordered in
+/// standard lexicographic order.  If this is not the case, after this
+/// step run `SparseReorder` to restore index ordering.
+///
+/// For example, if the serialized input is a `[2 x 3]` matrix representing two
+/// original `SparseTensor` objects:
+///
+///     index = [ 0]
+///             [10]
+///             [20]
+///     values = [1, 2, 3]
+///     shape = [50]
+///
+/// and
+///
+///     index = [ 2]
+///             [10]
+///     values = [4, 5]
+///     shape = [30]
+///
+/// then the final deserialized `SparseTensor` will be:
+///
+///     index = [0  0]
+///             [0 10]
+///             [0 20]
+///             [1  2]
+///             [1 10]
+///     values = [1, 2, 3, 4, 5]
+///     shape = [2 50]
+///
+/// - Parameter serialized_sparse: 2-D, The `N` serialized `SparseTensor` objects.
+///   Must have 3 columns.
+///
+/// - Attr dtype: The `dtype` of the serialized `SparseTensor` objects.
+@inlinable @inline(__always)
+public static func deserializeManySparse<Dtype: TensorFlowScalar>(
+  serializedSparse: StringTensor
+) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
+  let op = TFE_Op("DeserializeManySparse")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(serializedSparse)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Deserialize `SparseTensor` objects.
+///
+/// The input `serialized_sparse` must have the shape `[?, ?, ..., ?, 3]` where
+/// the last dimension stores serialized `SparseTensor` objects and the other N
+/// dimensions (N >= 0) correspond to a batch. The ranks of the original
+/// `SparseTensor` objects must all match. When the final `SparseTensor` is
+/// created, its rank is the rank of the incoming `SparseTensor` objects plus N;
+/// the sparse tensors have been concatenated along new dimensions, one for each
+/// batch.
+///
+/// The output `SparseTensor` object's shape values for the original dimensions
+/// are the max across the input `SparseTensor` objects' shape values for the
+/// corresponding dimensions. The new dimensions match the size of the batch.
+///
+/// The input `SparseTensor` objects' indices are assumed ordered in
+/// standard lexicographic order.  If this is not the case, after this
+/// step run `SparseReorder` to restore index ordering.
+///
+/// For example, if the serialized input is a `[2 x 3]` matrix representing two
+/// original `SparseTensor` objects:
+///
+///     index = [ 0]
+///             [10]
+///             [20]
+///     values = [1, 2, 3]
+///     shape = [50]
+///
+/// and
+///
+///     index = [ 2]
+///             [10]
+///     values = [4, 5]
+///     shape = [30]
+///
+/// then the final deserialized `SparseTensor` will be:
+///
+///     index = [0  0]
+///             [0 10]
+///             [0 20]
+///             [1  2]
+///             [1 10]
+///     values = [1, 2, 3, 4, 5]
+///     shape = [2 50]
+///
+/// - Parameter serialized_sparse: The serialized `SparseTensor` objects. The last dimension
+///   must have 3 columns.
+///
+/// - Attr dtype: The `dtype` of the serialized `SparseTensor` objects.
+@inlinable @inline(__always)
+public static func deserializeSparse<
+    Dtype: TensorFlowScalar,
+    Tserialized: TensorFlowScalar
+>(
+  serializedSparse: Tensor<Tserialized>
+) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
+  let op = TFE_Op("DeserializeSparse")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("Tserialized", Tserialized.tensorFlowDataType)
+  let _ = op.addInput(serializedSparse)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Deserialize `SparseTensor` objects.
+///
+/// The input `serialized_sparse` must have the shape `[?, ?, ..., ?, 3]` where
+/// the last dimension stores serialized `SparseTensor` objects and the other N
+/// dimensions (N >= 0) correspond to a batch. The ranks of the original
+/// `SparseTensor` objects must all match. When the final `SparseTensor` is
+/// created, its rank is the rank of the incoming `SparseTensor` objects plus N;
+/// the sparse tensors have been concatenated along new dimensions, one for each
+/// batch.
+///
+/// The output `SparseTensor` object's shape values for the original dimensions
+/// are the max across the input `SparseTensor` objects' shape values for the
+/// corresponding dimensions. The new dimensions match the size of the batch.
+///
+/// The input `SparseTensor` objects' indices are assumed ordered in
+/// standard lexicographic order.  If this is not the case, after this
+/// step run `SparseReorder` to restore index ordering.
+///
+/// For example, if the serialized input is a `[2 x 3]` matrix representing two
+/// original `SparseTensor` objects:
+///
+///     index = [ 0]
+///             [10]
+///             [20]
+///     values = [1, 2, 3]
+///     shape = [50]
+///
+/// and
+///
+///     index = [ 2]
+///             [10]
+///     values = [4, 5]
+///     shape = [30]
+///
+/// then the final deserialized `SparseTensor` will be:
+///
+///     index = [0  0]
+///             [0 10]
+///             [0 20]
+///             [1  2]
+///             [1 10]
+///     values = [1, 2, 3, 4, 5]
+///     shape = [2 50]
+///
+/// - Parameter serialized_sparse: The serialized `SparseTensor` objects. The last dimension
+///   must have 3 columns.
+///
+/// - Attr dtype: The `dtype` of the serialized `SparseTensor` objects.
+@inlinable @inline(__always)
+public static func deserializeSparse<Dtype: TensorFlowScalar>(
+  serializedSparse: StringTensor
+) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
+  let op = TFE_Op("DeserializeSparse")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("Tserialized", TensorDataType(TF_STRING))
+  let _ = op.addInput(serializedSparse)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Deletes the resource specified by the handle.
+///
+/// All subsequent operations using the resource will result in a NotFound
+/// error status.
+///
+/// - Parameter resource: handle to the resource to delete.
+///
+/// - Attr ignore_lookup_error: whether to ignore the error when the resource
+///   doesn't exist.
+@inlinable @inline(__always)
+public static func destroyResourceOp(
+  resource: ResourceHandle,
+  ignoreLookupError: Bool = true
+) {
+  let op = TFE_Op("DestroyResourceOp")
+  op.setAttr("ignore_lookup_error", ignoreLookupError)
+  let _ = op.addInput(resource)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func devicePlacementOp(
+) -> StringTensor {
+  let op = TFE_Op("DevicePlacementOp")
+  
+  return op.execute(Int(1))
+}
+
+/// Returns a diagonal tensor with a given diagonal values.
+///
+/// Given a `diagonal`, this operation returns a tensor with the `diagonal` and
+/// everything else padded with zeros. The diagonal is computed as follows:
+///
+/// Assume `diagonal` has dimensions [D1,..., Dk], then the output is a tensor of
+/// rank 2k with dimensions [D1,..., Dk, D1,..., Dk] where:
+///
+/// `output[i1,..., ik, i1,..., ik] = diagonal[i1, ..., ik]` and 0 everywhere else.
+///
+/// For example:
+///
+/// ```
+/// # 'diagonal' is [1, 2, 3, 4]
+/// tf.diag(diagonal) ==> [[1, 0, 0, 0]
+///                        [0, 2, 0, 0]
+///                        [0, 0, 3, 0]
+///                        [0, 0, 0, 4]]
+/// ```
+///
+/// - Parameter diagonal: Rank k tensor where k is at most 1.
+@inlinable @inline(__always)
+public static func diag<T: Numeric & TensorFlowScalar>(
+  diagonal: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Diag")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(diagonal)
+  return op.execute(Int(1))
+}
+
+/// Returns the diagonal part of the tensor.
+///
+/// This operation returns a tensor with the `diagonal` part
+/// of the `input`. The `diagonal` part is computed as follows:
+///
+/// Assume `input` has dimensions `[D1,..., Dk, D1,..., Dk]`, then the output is a
+/// tensor of rank `k` with dimensions `[D1,..., Dk]` where:
+///
+/// `diagonal[i1,..., ik] = input[i1, ..., ik, i1,..., ik]`.
+///
+/// For example:
+///
+/// ```
+/// # 'input' is [[1, 0, 0, 0]
+///               [0, 2, 0, 0]
+///               [0, 0, 3, 0]
+///               [0, 0, 0, 4]]
+///
+/// tf.diag_part(input) ==> [1, 2, 3, 4]
+/// ```
+///
+/// - Parameter input: Rank k tensor where k is even and not zero.
+///
+/// - Output diagonal: The extracted diagonal.
+@inlinable @inline(__always)
+public static func diagPart<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("DiagPart")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Computes Psi, the derivative of Lgamma (the log of the absolute value of
+///
+/// `Gamma(x)`), element-wise.
+@inlinable @inline(__always)
+public static func digamma<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Digamma")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the grayscale dilation of 4-D `input` and 3-D `filter` tensors.
+///
+/// The `input` tensor has shape `[batch, in_height, in_width, depth]` and the
+/// `filter` tensor has shape `[filter_height, filter_width, depth]`, i.e., each
+/// input channel is processed independently of the others with its own structuring
+/// function. The `output` tensor has shape
+/// `[batch, out_height, out_width, depth]`. The spatial dimensions of the output
+/// tensor depend on the `padding` algorithm. We currently only support the default
+/// "NHWC" `data_format`.
+///
+/// In detail, the grayscale morphological 2-D dilation is the max-sum correlation
+/// (for consistency with `conv2d`, we use unmirrored filters):
+///
+///     output[b, y, x, c] =
+///        max_{dy, dx} input[b,
+///                           strides[1] * y + rates[1] * dy,
+///                           strides[2] * x + rates[2] * dx,
+///                           c] +
+///                     filter[dy, dx, c]
+///
+/// Max-pooling is a special case when the filter has size equal to the pooling
+/// kernel size and contains all zeros.
+///
+/// Note on duality: The dilation of `input` by the `filter` is equal to the
+/// negation of the erosion of `-input` by the reflected `filter`.
+///
+/// - Parameters:
+///   - input: 4-D with shape `[batch, in_height, in_width, depth]`.
+///   - filter: 3-D with shape `[filter_height, filter_width, depth]`.
+///
+/// - Attrs:
+///   - strides: The stride of the sliding window for each dimension of the input
+///     tensor. Must be: `[1, stride_height, stride_width, 1]`.
+///   - rates: The input stride for atrous morphological dilation. Must be:
+///     `[1, rate_height, rate_width, 1]`.
+///   - padding: The type of padding algorithm to use.
+///
+/// - Output output: 4-D with shape `[batch, out_height, out_width, depth]`.
+@inlinable @inline(__always)
+public static func dilation2D<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  filter: Tensor<T>,
+  strides: [Int32],
+  rates: [Int32],
+  padding: Padding
+) -> Tensor<T> {
+  let op = TFE_Op("Dilation2D")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("rates", rates)
+  op.setAttr("padding", padding.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient of morphological 2-D dilation with respect to the filter.
+///
+/// - Parameters:
+///   - input: 4-D with shape `[batch, in_height, in_width, depth]`.
+///   - filter: 3-D with shape `[filter_height, filter_width, depth]`.
+///   - out_backprop: 4-D with shape `[batch, out_height, out_width, depth]`.
+///
+/// - Attrs:
+///   - strides: 1-D of length 4. The stride of the sliding window for each dimension of
+///     the input tensor. Must be: `[1, stride_height, stride_width, 1]`.
+///   - rates: 1-D of length 4. The input stride for atrous morphological dilation.
+///     Must be: `[1, rate_height, rate_width, 1]`.
+///   - padding: The type of padding algorithm to use.
+///
+/// - Output filter_backprop: 3-D with shape `[filter_height, filter_width, depth]`.
+@inlinable @inline(__always)
+public static func dilation2DBackpropFilter<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  filter: Tensor<T>,
+  outBackprop: Tensor<T>,
+  strides: [Int32],
+  rates: [Int32],
+  padding: Padding
+) -> Tensor<T> {
+  let op = TFE_Op("Dilation2DBackpropFilter")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("rates", rates)
+  op.setAttr("padding", padding.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(outBackprop)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient of morphological 2-D dilation with respect to the input.
+///
+/// - Parameters:
+///   - input: 4-D with shape `[batch, in_height, in_width, depth]`.
+///   - filter: 3-D with shape `[filter_height, filter_width, depth]`.
+///   - out_backprop: 4-D with shape `[batch, out_height, out_width, depth]`.
+///
+/// - Attrs:
+///   - strides: 1-D of length 4. The stride of the sliding window for each dimension of
+///     the input tensor. Must be: `[1, stride_height, stride_width, 1]`.
+///   - rates: 1-D of length 4. The input stride for atrous morphological dilation.
+///     Must be: `[1, rate_height, rate_width, 1]`.
+///   - padding: The type of padding algorithm to use.
+///
+/// - Output in_backprop: 4-D with shape `[batch, in_height, in_width, depth]`.
+@inlinable @inline(__always)
+public static func dilation2DBackpropInput<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  filter: Tensor<T>,
+  outBackprop: Tensor<T>,
+  strides: [Int32],
+  rates: [Int32],
+  padding: Padding
+) -> Tensor<T> {
+  let op = TFE_Op("Dilation2DBackpropInput")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("rates", rates)
+  op.setAttr("padding", padding.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(outBackprop)
+  return op.execute(Int(1))
+}
+
+/// Returns x / y element-wise.
+///
+/// *NOTE*: `Div` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func div<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Div")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns 0 if the denominator is zero.
+///
+///
+/// *NOTE*: `DivNoNan` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func divNoNan<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("DivNoNan")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Draw bounding boxes on a batch of images.
+///
+/// Outputs a copy of `images` but draws on top of the pixels zero or more bounding
+/// boxes specified by the locations in `boxes`. The coordinates of the each
+/// bounding box in `boxes` are encoded as `[y_min, x_min, y_max, x_max]`. The
+/// bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
+/// height of the underlying image.
+///
+/// For example, if an image is 100 x 200 pixels (height x width) and the bounding
+/// box is `[0.1, 0.2, 0.5, 0.9]`, the upper-left and bottom-right coordinates of
+/// the bounding box will be `(40, 10)` to `(180, 50)` (in (x,y) coordinates).
+///
+/// Parts of the bounding box may fall outside the image.
+///
+/// - Parameters:
+///   - images: 4-D with shape `[batch, height, width, depth]`. A batch of images.
+///   - boxes: 3-D with shape `[batch, num_bounding_boxes, 4]` containing bounding
+///     boxes.
+///
+/// - Output output: 4-D with the same shape as `images`. The batch of input images with
+///   bounding boxes drawn on the images.
+@inlinable @inline(__always)
+public static func drawBoundingBoxes<T: FloatingPoint & TensorFlowScalar>(
+  images: Tensor<T>,
+  boxes: Tensor<Float>
+) -> Tensor<T> {
+  let op = TFE_Op("DrawBoundingBoxes")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(images)
+  let _ = op.addInput(boxes)
+  return op.execute(Int(1))
+}
+
+/// Draw bounding boxes on a batch of images.
+///
+/// Outputs a copy of `images` but draws on top of the pixels zero or more bounding
+/// boxes specified by the locations in `boxes`. The coordinates of the each
+/// bounding box in `boxes` are encoded as `[y_min, x_min, y_max, x_max]`. The
+/// bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
+/// height of the underlying image.
+///
+/// For example, if an image is 100 x 200 pixels (height x width) and the bounding
+/// box is `[0.1, 0.2, 0.5, 0.9]`, the upper-left and bottom-right coordinates of
+/// the bounding box will be `(40, 10)` to `(100, 50)` (in (x,y) coordinates).
+///
+/// Parts of the bounding box may fall outside the image.
+///
+/// - Parameters:
+///   - images: 4-D with shape `[batch, height, width, depth]`. A batch of images.
+///   - boxes: 3-D with shape `[batch, num_bounding_boxes, 4]` containing bounding
+///     boxes.
+///   - colors: 2-D. A list of RGBA colors to cycle through for the boxes.
+///
+/// - Output output: 4-D with the same shape as `images`. The batch of input images with
+///   bounding boxes drawn on the images.
+@inlinable @inline(__always)
+public static func drawBoundingBoxesV2<T: FloatingPoint & TensorFlowScalar>(
+  images: Tensor<T>,
+  boxes: Tensor<Float>,
+  colors: Tensor<Float>
+) -> Tensor<T> {
+  let op = TFE_Op("DrawBoundingBoxesV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(images)
+  let _ = op.addInput(boxes)
+  let _ = op.addInput(colors)
+  return op.execute(Int(1))
+}
+
+/// Partitions `data` into `num_partitions` tensors using indices from `partitions`.
+///
+/// For each index tuple `js` of size `partitions.ndim`, the slice `data[js, ...]`
+/// becomes part of `outputs[partitions[js]]`.  The slices with `partitions[js] = i`
+/// are placed in `outputs[i]` in lexicographic order of `js`, and the first
+/// dimension of `outputs[i]` is the number of entries in `partitions` equal to `i`.
+/// In detail,
+///
+/// ```python
+///     outputs[i].shape = [sum(partitions == i)] + data.shape[partitions.ndim:]
+///
+///     outputs[i] = pack([data[js, ...] for js if partitions[js] == i])
+/// ```
+///
+/// `data.shape` must start with `partitions.shape`.
+///
+/// For example:
+///
+/// ```python
+///     # Scalar partitions.
+///     partitions = 1
+///     num_partitions = 2
+///     data = [10, 20]
+///     outputs[0] = []  # Empty with shape [0, 2]
+///     outputs[1] = [[10, 20]]
+///
+///     # Vector partitions.
+///     partitions = [0, 0, 1, 1, 0]
+///     num_partitions = 2
+///     data = [10, 20, 30, 40, 50]
+///     outputs[0] = [10, 20, 50]
+///     outputs[1] = [30, 40]
+/// ```
+///
+/// See `dynamic_stitch` for an example on how to merge partitions back.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/DynamicPartition.png" alt>
+/// </div>
+///
+/// - Parameter partitions: Any shape.  Indices in the range `[0, num_partitions)`.
+///
+/// - Attr num_partitions: The number of partitions to output.
+@inlinable @inline(__always)
+public static func dynamicPartition<T: TensorFlowScalar>(
+  data: Tensor<T>,
+  partitions: Tensor<Int32>,
+  numPartitions: Int64
+) -> [Tensor<T>] {
+  let op = TFE_Op("DynamicPartition")
+  op.setAttr("num_partitions", numPartitions)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(partitions)
+  return op.execute(Int(numPartitions))
+}
+
+/// Interleave the values from the `data` tensors into a single tensor.
+///
+/// Builds a merged tensor such that
+///
+/// ```python
+///     merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
+/// ```
+///
+/// For example, if each `indices[m]` is scalar or vector, we have
+///
+/// ```python
+///     # Scalar indices:
+///     merged[indices[m], ...] = data[m][...]
+///
+///     # Vector indices:
+///     merged[indices[m][i], ...] = data[m][i, ...]
+/// ```
+///
+/// Each `data[i].shape` must start with the corresponding `indices[i].shape`,
+/// and the rest of `data[i].shape` must be constant w.r.t. `i`.  That is, we
+/// must have `data[i].shape = indices[i].shape + constant`.  In terms of this
+/// `constant`, the output shape is
+///
+///     merged.shape = [max(indices)] + constant
+///
+/// Values are merged in order, so if an index appears in both `indices[m][i]` and
+/// `indices[n][j]` for `(m,i) < (n,j)` the slice `data[n][j]` will appear in the
+/// merged result. If you do not need this guarantee, ParallelDynamicStitch might
+/// perform better on some devices.
+///
+/// For example:
+///
+/// ```python
+///     indices[0] = 6
+///     indices[1] = [4, 1]
+///     indices[2] = [[5, 2], [0, 3]]
+///     data[0] = [61, 62]
+///     data[1] = [[41, 42], [11, 12]]
+///     data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
+///     merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
+///               [51, 52], [61, 62]]
+/// ```
+///
+/// This method can be used to merge partitions created by `dynamic_partition`
+/// as illustrated on the following example:
+///
+/// ```python
+///     # Apply function (increments x_i) on elements for which a certain condition
+///     # apply (x_i != -1 in this example).
+///     x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
+///     condition_mask=tf.not_equal(x,tf.constant(-1.))
+///     partitioned_data = tf.dynamic_partition(
+///         x, tf.cast(condition_mask, tf.int32) , 2)
+///     partitioned_data[1] = partitioned_data[1] + 1.0
+///     condition_indices = tf.dynamic_partition(
+///         tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
+///     x = tf.dynamic_stitch(condition_indices, partitioned_data)
+///     # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
+///     # unchanged.
+/// ```
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/DynamicStitch.png" alt>
+/// </div>
+@inlinable @inline(__always)
+public static func dynamicStitch<T: TensorFlowScalar>(
+  indices: [Tensor<Int32>],
+  data: [Tensor<T>]
+) -> Tensor<T> {
+  let op = TFE_Op("DynamicStitch")
+  op.setAttr("N", indices.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInputList(indices)
+  let _ = op.addInputList(data)
+  return op.execute(Int(1))
+}
+
+/// 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.
+@inlinable @inline(__always)
+public static func eagerPyFunc<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup
+>(
+  _ input: Tin,
+  token: String
+) -> Tout {
+  let op = TFE_Op("EagerPyFunc")
+  op.setAttr("token", token)
+  op.setAttr("Tin", input._typeList)
+  op.setAttr("Tout", Tout._typeList)
+  let _ = op.addInputList(input)
+  return op.execute(Int(Tout._typeList.count))
+}
+
+/// Computes the (possibly normalized) Levenshtein Edit Distance.
+///
+/// The inputs are variable-length sequences provided by SparseTensors
+///   (hypothesis_indices, hypothesis_values, hypothesis_shape)
+/// and
+///   (truth_indices, truth_values, truth_shape).
+///
+/// The inputs are:
+///
+/// - Parameters:
+///   - hypothesis_indices: The indices of the hypothesis list SparseTensor.
+///     This is an N x R int64 matrix.
+///   - hypothesis_values: The values of the hypothesis list SparseTensor.
+///     This is an N-length vector.
+///   - hypothesis_shape: The shape of the hypothesis list SparseTensor.
+///     This is an R-length vector.
+///   - truth_indices: The indices of the truth list SparseTensor.
+///     This is an M x R int64 matrix.
+///   - truth_values: The values of the truth list SparseTensor.
+///     This is an M-length vector.
+///   - truth_shape: truth indices, vector.
+///
+/// - Attr normalize: boolean (if true, edit distances are normalized by length of truth).
+///
+///   The output is:
+///
+/// - Output output: A dense float tensor with rank R - 1.
+///
+///   For the example input:
+///
+///       // hypothesis represents a 2x1 matrix with variable-length values:
+///       //   (0,0) = ["a"]
+///       //   (1,0) = ["b"]
+///       hypothesis_indices = [[0, 0, 0],
+///                             [1, 0, 0]]
+///       hypothesis_values = ["a", "b"]
+///       hypothesis_shape = [2, 1, 1]
+///
+///       // truth represents a 2x2 matrix with variable-length values:
+///       //   (0,0) = []
+///       //   (0,1) = ["a"]
+///       //   (1,0) = ["b", "c"]
+///       //   (1,1) = ["a"]
+///       truth_indices = [[0, 1, 0],
+///                        [1, 0, 0],
+///                        [1, 0, 1],
+///                        [1, 1, 0]]
+///       truth_values = ["a", "b", "c", "a"]
+///       truth_shape = [2, 2, 2]
+///       normalize = true
+///
+///   The output will be:
+///
+///       // output is a 2x2 matrix with edit distances normalized by truth lengths.
+///       output = [[inf, 1.0],  // (0,0): no truth, (0,1): no hypothesis
+///                 [0.5, 1.0]]  // (1,0): addition, (1,1): no hypothesis
+@inlinable @inline(__always)
+public static func editDistance<T: TensorFlowScalar>(
+  hypothesisIndices: Tensor<Int64>,
+  hypothesisValues: Tensor<T>,
+  hypothesisShape: Tensor<Int64>,
+  truthIndices: Tensor<Int64>,
+  truthValues: Tensor<T>,
+  truthShape: Tensor<Int64>,
+  normalize: Bool = true
+) -> Tensor<Float> {
+  let op = TFE_Op("EditDistance")
+  op.setAttr("normalize", normalize)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(hypothesisIndices)
+  let _ = op.addInput(hypothesisValues)
+  let _ = op.addInput(hypothesisShape)
+  let _ = op.addInput(truthIndices)
+  let _ = op.addInput(truthValues)
+  let _ = op.addInput(truthShape)
+  return op.execute(Int(1))
+}
+
+/// Computes exponential linear: `exp(features) - 1` if < 0, `features` otherwise.
+///
+/// See [Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)
+/// ](http://arxiv.org/abs/1511.07289)
+@inlinable @inline(__always)
+public static func elu<T: FloatingPoint & TensorFlowScalar>(
+  features: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Elu")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(features)
+  return op.execute(Int(1))
+}
+
+/// Computes gradients for the exponential linear (Elu) operation.
+///
+/// - Parameters:
+///   - gradients: The backpropagated gradients to the corresponding Elu operation.
+///   - outputs: The outputs of the corresponding Elu operation.
+///
+/// - Output backprops: The gradients: `gradients * (outputs + 1)` if outputs < 0,
+///   `gradients` otherwise.
+@inlinable @inline(__always)
+public static func eluGrad<T: FloatingPoint & TensorFlowScalar>(
+  gradients: Tensor<T>,
+  outputs: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("EluGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(gradients)
+  let _ = op.addInput(outputs)
+  return op.execute(Int(1))
+}
+
+/// Creates a tensor with the given shape.
+///
+/// This operation creates a tensor of `shape` and `dtype`.
+///
+/// - Parameter shape: 1-D. Represents the shape of the output tensor.
+///
+/// - Attr init: If True, initialize the returned tensor with the default value of dtype.  Otherwise, the implementation is free not to initializethe tensor's content.
+///
+/// - Output output: A `Tensor` of type `T`.
+@inlinable @inline(__always)
+public static func empty<Dtype: TensorFlowScalar>(
+  shape: Tensor<Int32>,
+  init_: Bool = false
+) -> Tensor<Dtype> {
+  let op = TFE_Op("Empty")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("init", init_)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Creates and returns an empty tensor list.
+///
+/// All list elements must be tensors of dtype element_dtype and shape compatible
+/// with element_shape.
+///
+/// handle: an empty tensor list.
+/// element_dtype: the type of elements in the list.
+/// element_shape: a shape compatible with that of elements in the list.
+@inlinable @inline(__always)
+public static func emptyTensorList<ShapeType: BinaryInteger & TensorFlowScalar>(
+  elementShape: Tensor<ShapeType>,
+  maxNumElements: Tensor<Int32>,
+  elementDtype: TensorDataType
+) -> VariantHandle {
+  let op = TFE_Op("EmptyTensorList")
+  op.setAttr("element_dtype", elementDtype)
+  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
+  let _ = op.addInput(elementShape)
+  let _ = op.addInput(maxNumElements)
+  return op.execute(Int(1))
+}
+
+/// Encode strings into web-safe base64 format.
+///
+/// Refer to the following article for more information on base64 format:
+/// en.wikipedia.org/wiki/Base64. Base64 strings may have padding with '=' at the
+/// end so that the encoded has length multiple of 4. See Padding section of the
+/// link above.
+///
+/// Web-safe means that the encoder uses - and _ instead of + and /.
+///
+/// - Parameter input: Strings to be encoded.
+///
+/// - Attr pad: Bool whether padding is applied at the ends.
+///
+/// - Output output: Input strings encoded in base64.
+@inlinable @inline(__always)
+public static func encodeBase64(
+  _ input: StringTensor,
+  pad: Bool = false
+) -> StringTensor {
+  let op = TFE_Op("EncodeBase64")
+  op.setAttr("pad", pad)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// JPEG-encode an image.
+///
+/// `image` is a 3-D uint8 Tensor of shape `[height, width, channels]`.
+///
+/// The attr `format` can be used to override the color format of the encoded
+/// output.  Values can be:
+///
+/// *   `''`: Use a default format based on the number of channels in the image.
+/// *   `grayscale`: Output a grayscale JPEG image.  The `channels` dimension
+///     of `image` must be 1.
+/// *   `rgb`: Output an RGB JPEG image. The `channels` dimension
+///     of `image` must be 3.
+///
+/// If `format` is not specified or is the empty string, a default format is picked
+/// in function of the number of channels in `image`:
+///
+/// *   1: Output a grayscale image.
+/// *   3: Output an RGB image.
+///
+/// - Parameter image: 3-D with shape `[height, width, channels]`.
+///
+/// - Attrs:
+///   - format: Per pixel image format.
+///   - quality: Quality of the compression from 0 to 100 (higher is better and slower).
+///   - progressive: If True, create a JPEG that loads progressively (coarse to fine).
+///   - optimize_size: If True, spend CPU/RAM to reduce size with no quality change.
+///   - chroma_downsampling: See http://en.wikipedia.org/wiki/Chroma_subsampling.
+///   - density_unit: Unit used to specify `x_density` and `y_density`:
+///     pixels per inch (`'in'`) or centimeter (`'cm'`).
+///   - x_density: Horizontal pixels per density unit.
+///   - y_density: Vertical pixels per density unit.
+///   - xmp_metadata: If not empty, embed this XMP metadata in the image header.
+///
+/// - Output contents: 0-D. JPEG-encoded image.
+@inlinable @inline(__always)
+public static func encodeJpeg(
+  image: Tensor<UInt8>,
+  format: Format,
+  quality: Int64 = 95,
+  progressive: Bool = false,
+  optimizeSize: Bool = false,
+  chromaDownsampling: Bool = true,
+  densityUnit: DensityUnit = .in_,
+  xDensity: Int64 = 300,
+  yDensity: Int64 = 300,
+  xmpMetadata: String
+) -> StringTensor {
+  let op = TFE_Op("EncodeJpeg")
+  op.setAttr("format", format.cName)
+  op.setAttr("quality", quality)
+  op.setAttr("progressive", progressive)
+  op.setAttr("optimize_size", optimizeSize)
+  op.setAttr("chroma_downsampling", chromaDownsampling)
+  op.setAttr("density_unit", densityUnit.cName)
+  op.setAttr("x_density", xDensity)
+  op.setAttr("y_density", yDensity)
+  op.setAttr("xmp_metadata", xmpMetadata)
+  let _ = op.addInput(image)
+  return op.execute(Int(1))
+}
+
+/// JPEG encode input image with provided compression quality.
+///
+/// `image` is a 3-D uint8 Tensor of shape `[height, width, channels]`.
+/// `quality` is an int32 jpeg compression quality value between 0 and 100.
+///
+///
+/// - Parameters:
+///   - images: Images to adjust.  At least 3-D.
+///   - quality: An int quality to encode to.
+///
+/// - Output contents: 0-D. JPEG-encoded image.
+@inlinable @inline(__always)
+public static func encodeJpegVariableQuality(
+  images: Tensor<UInt8>,
+  quality: Tensor<Int32>
+) -> StringTensor {
+  let op = TFE_Op("EncodeJpegVariableQuality")
+  let _ = op.addInput(images)
+  let _ = op.addInput(quality)
+  return op.execute(Int(1))
+}
+
+/// PNG-encode an image.
+///
+/// `image` is a 3-D uint8 or uint16 Tensor of shape `[height, width, channels]`
+/// where `channels` is:
+///
+/// *   1: for grayscale.
+/// *   2: for grayscale + alpha.
+/// *   3: for RGB.
+/// *   4: for RGBA.
+///
+/// The ZLIB compression level, `compression`, can be -1 for the PNG-encoder
+/// default or a value from 0 to 9.  9 is the highest compression level, generating
+/// the smallest output, but is slower.
+///
+/// - Parameter image: 3-D with shape `[height, width, channels]`.
+///
+/// - Attr compression: Compression level.
+///
+/// - Output contents: 0-D. PNG-encoded image.
+@inlinable @inline(__always)
+public static func encodePng<T: UnsignedInteger & TensorFlowScalar>(
+  image: Tensor<T>,
+  compression: Int64 = -1
+) -> StringTensor {
+  let op = TFE_Op("EncodePng")
+  op.setAttr("compression", compression)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(image)
+  return op.execute(Int(1))
+}
+
+/// The op serializes protobuf messages provided in the input tensors.
+///
+/// The types of the tensors in `values` must match the schema for the
+/// fields specified in `field_names`. All the tensors in `values` must
+/// have a common shape prefix, *batch_shape*.
+///
+/// The `sizes` tensor specifies repeat counts for each field.  The repeat
+/// count (last dimension) of a each tensor in `values` must be greater
+/// than or equal to corresponding repeat count in `sizes`.
+///
+/// A `message_type` name must be provided to give context for the field
+/// names. The actual message descriptor can be looked up either in the
+/// linked-in descriptor pool or a filename provided by the caller using
+/// the `descriptor_source` attribute.
+///
+/// The `descriptor_source` attribute selects a source of protocol
+/// descriptors to consult when looking up `message_type`. This may be a
+/// filename containing a serialized `FileDescriptorSet` message,
+/// or the special value `local://`, in which case only descriptors linked
+/// into the code will be searched; the filename can be on any filesystem
+/// accessible to TensorFlow.
+///
+/// You can build a `descriptor_source` file using the `--descriptor_set_out`
+/// and `--include_imports` options to the protocol compiler `protoc`.
+///
+/// The `local://` database only covers descriptors linked into the
+/// code via C++ libraries, not Python imports. You can link in a proto descriptor
+/// by creating a cc_library target with alwayslink=1.
+///
+/// There are a few special cases in the value mapping:
+///
+/// Submessage and group fields must be pre-serialized as TensorFlow strings.
+///
+/// TensorFlow lacks support for unsigned int64s, so they must be
+/// represented as `tf.int64` with the same twos-complement bit pattern
+/// (the obvious way).
+///
+/// Unsigned int32 values can be represented exactly with `tf.int64`, or
+/// with sign wrapping if the input is of type `tf.int32`.
+///
+/// - Parameters:
+///   - sizes: Tensor of int32 with shape `[batch_shape, len(field_names)]`.
+///   - values: List of tensors containing values for the corresponding field.
+///
+/// - Attrs:
+///   - field_names: List of strings containing proto field names.
+///   - message_type: Name of the proto message type to decode.
+///   - Tinput_types: The input types.
+///
+/// - Output bytes: Tensor of serialized protos with shape `batch_shape`.
+@inlinable @inline(__always)
+public static func encodeProto<TinputTypes: TensorArrayProtocol>(
+  sizes: Tensor<Int32>,
+  _ values: TinputTypes,
+  fieldNames: [String],
+  messageType: String,
+  descriptorSource: String = "local://"
+) -> StringTensor {
+  let op = TFE_Op("EncodeProto")
+  op.setAttr("field_names", fieldNames)
+  op.setAttr("message_type", messageType)
+  op.setAttr("descriptor_source", descriptorSource)
+  op.setAttr("Tinput_types", values._typeList)
+  let _ = op.addInput(sizes)
+  let _ = op.addInputList(values)
+  return op.execute(Int(1))
+}
+
+/// Encode audio data using the WAV file format.
+///
+/// This operation will generate a string suitable to be saved out to create a .wav
+/// audio file. It will be encoded in the 16-bit PCM format. It takes in float
+/// values in the range -1.0f to 1.0f, and any outside that value will be clamped to
+/// that range.
+///
+/// `audio` is a 2-D float Tensor of shape `[length, channels]`.
+/// `sample_rate` is a scalar Tensor holding the rate to use (e.g. 44100).
+///
+/// - Parameters:
+///   - audio: 2-D with shape `[length, channels]`.
+///   - sample_rate: Scalar containing the sample frequency.
+///
+/// - Output contents: 0-D. WAV-encoded file contents.
+@inlinable @inline(__always)
+public static func encodeWav(
+  audio: Tensor<Float>,
+  sampleRate: Tensor<Int32>
+) -> StringTensor {
+  let op = TFE_Op("EncodeWav")
+  let _ = op.addInput(audio)
+  let _ = op.addInput(sampleRate)
+  return op.execute(Int(1))
+}
+
+/// An op that enqueues a list of input batch tensors to TPUEmbedding.
+///
+/// - Parameters:
+///   - batch: A list of 1D tensors, one for each embedding table, containing the
+///     indices into the tables.
+///   - mode_override: A string input that overrides the mode specified in the
+///     TPUEmbeddingConfiguration. Supported values are {'unspecified', 'inference',
+///     'training', 'backward_pass_only'}. When set to 'unspecified', the mode set
+///     in TPUEmbeddingConfiguration is used, otherwise mode_override is used.
+///
+/// - Attr device_ordinal: The TPU device to use. Should be >= 0 and less than the number
+///   of TPU cores in the task on which the node is placed.
+@inlinable @inline(__always)
+public static func enqueueTPUEmbeddingIntegerBatch(
+  batch: [Tensor<Int32>],
+  modeOverride: StringTensor,
+  deviceOrdinal: Int64 = -1
+) {
+  let op = TFE_Op("EnqueueTPUEmbeddingIntegerBatch")
+  op.setAttr("N", batch.count)
+  op.setAttr("device_ordinal", deviceOrdinal)
+  let _ = op.addInputList(batch)
+  let _ = op.addInput(modeOverride)
+  op.execute()
+}
+
+/// An op that enqueues TPUEmbedding input indices from a SparseTensor.
+///
+/// This Op eases the porting of code that uses embedding_lookup_sparse(),
+/// although some Python preprocessing of the SparseTensor arguments to
+/// embedding_lookup_sparse() is required to produce the arguments to this Op,
+/// since only a single EnqueueTPUEmbeddingSparseBatch Op is allowed per training
+/// step.
+///
+/// The tensors at corresponding positions in the three input lists
+/// must have the same shape, i.e. rank 1 with dim_size() equal to the total
+/// number of lookups into the table described by the corresponding table_id.
+///
+/// - Parameters:
+///   - sample_indices: A list of rank 1 Tensors specifying the training example and
+///     feature to which the corresponding embedding_indices and aggregation_weights
+///     values belong. sample_indices[i] must equal b * nf + f, where nf is the
+///     number of features from the corresponding table, f is in [0, nf), and
+///     b is in [0, batch size).
+///   - embedding_indices: A list of rank 1 Tensors, indices into the embedding tables.
+///   - aggregation_weights: A list of rank 1 Tensors containing per sample -- i.e. per
+///     (training example, feature) -- aggregation weights.
+///   - mode_override: A string input that overrides the mode specified in the
+///     TPUEmbeddingConfiguration. Supported values are {'unspecified', 'inference',
+///     'training', 'backward_pass_only'}. When set to 'unspecified', the mode set
+///     in TPUEmbeddingConfiguration is used, otherwise mode_override is used.
+///
+/// - Attrs:
+///   - device_ordinal: The TPU device to use. Should be >= 0 and less than the number
+///     of TPU cores in the task on which the node is placed.
+///   - combiners: A list of string scalars, one for each embedding table that specify
+///     how to normalize the embedding activations after weighted summation.
+///     Supported combiners are 'mean', 'sum', or 'sqrtn'. It is invalid to have
+///     the sum of the weights be 0 for 'mean' or the sum of the squared weights be
+///     0 for 'sqrtn'. If combiners isn't passed, the default is to use 'sum' for
+///     all tables.
+@inlinable @inline(__always)
+public static func enqueueTPUEmbeddingSparseBatch<
+    T1: BinaryInteger & TensorFlowScalar,
+    T2: BinaryInteger & TensorFlowScalar,
+    T3: FloatingPoint & TensorFlowScalar
+>(
+  sampleIndices: [Tensor<T1>],
+  embeddingIndices: [Tensor<T2>],
+  aggregationWeights: [Tensor<T3>],
+  modeOverride: StringTensor,
+  deviceOrdinal: Int64 = -1,
+  combiners: [String]
+) {
+  let op = TFE_Op("EnqueueTPUEmbeddingSparseBatch")
+  op.setAttr("T1", T1.tensorFlowDataType)
+  op.setAttr("T2", T2.tensorFlowDataType)
+  op.setAttr("T3", T3.tensorFlowDataType)
+  op.setAttr("N", sampleIndices.count)
+  op.setAttr("device_ordinal", deviceOrdinal)
+  op.setAttr("combiners", combiners)
+  let _ = op.addInputList(sampleIndices)
+  let _ = op.addInputList(embeddingIndices)
+  let _ = op.addInputList(aggregationWeights)
+  let _ = op.addInput(modeOverride)
+  op.execute()
+}
+
+/// Eases the porting of code that uses tf.nn.embedding_lookup_sparse().
+///
+/// sample_indices[i], embedding_indices[i] and aggregation_weights[i] correspond
+/// to the ith feature. table_ids[i] indicates which embedding table to look up ith
+/// feature.
+///
+/// The tensors at corresponding positions in the three input lists (sample_indices,
+/// embedding_indices and aggregation_weights) must have the same shape, i.e. rank 1
+/// with dim_size() equal to the total number of lookups into the table described by
+/// the corresponding feature.
+///
+/// - Parameters:
+///   - sample_indices: A list of rank 1 Tensors specifying the training example to
+///     which the corresponding embedding_indices and aggregation_weights values
+///     belong. It corresponds to sp_ids.indices[:,0] in  embedding_lookup_sparse().
+///   - embedding_indices: A list of rank 1 Tensors, indices into the embedding tables.
+///     It corresponds to sp_ids.values in embedding_lookup_sparse().
+///   - aggregation_weights: A list of rank 1 Tensors containing per training example
+///     aggregation weights. It corresponds to sp_weights.values in
+///     embedding_lookup_sparse().
+///   - mode_override: A string input that overrides the mode specified in the
+///     TPUEmbeddingConfiguration. Supported values are {'unspecified', 'inference',
+///     'training', 'backward_pass_only'}. When set to 'unspecified', the mode set
+///     in TPUEmbeddingConfiguration is used, otherwise mode_override is used.
+///
+/// - Attrs:
+///   - device_ordinal: The TPU device to use. Should be >= 0 and less than the number
+///     of TPU cores in the task on which the node is placed.
+///   - combiners: A list of string scalars, one for each embedding table that specify
+///     how to normalize the embedding activations after weighted summation.
+///     Supported combiners are 'mean', 'sum', or 'sqrtn'. It is invalid to have
+///     the sum of the weights be 0 for 'mean' or the sum of the squared weights be
+///     0 for 'sqrtn'. If combiners isn't passed, the default is to use 'sum' for
+///     all tables.
+///   - table_ids: A list of integers specifying the identifier of the embedding table
+///     (offset of TableDescriptor in the TPUEmbeddingConfiguration) to lookup the
+///     corresponding input. The ith input is looked up using table_ids[i]. The size
+///     of the table_ids list must be equal to that of sample_indices,
+///     embedding_indices and aggregation_weights.
+@inlinable @inline(__always)
+public static func enqueueTPUEmbeddingSparseTensorBatch<
+    T1: BinaryInteger & TensorFlowScalar,
+    T2: BinaryInteger & TensorFlowScalar,
+    T3: FloatingPoint & TensorFlowScalar
+>(
+  sampleIndices: [Tensor<T1>],
+  embeddingIndices: [Tensor<T2>],
+  aggregationWeights: [Tensor<T3>],
+  modeOverride: StringTensor,
+  deviceOrdinal: Int64 = -1,
+  combiners: [String],
+  tableIds: [Int32],
+  maxSequenceLengths: [Int32]
+) {
+  let op = TFE_Op("EnqueueTPUEmbeddingSparseTensorBatch")
+  op.setAttr("T1", T1.tensorFlowDataType)
+  op.setAttr("T2", T2.tensorFlowDataType)
+  op.setAttr("T3", T3.tensorFlowDataType)
+  op.setAttr("N", sampleIndices.count)
+  op.setAttr("device_ordinal", deviceOrdinal)
+  op.setAttr("combiners", combiners)
+  op.setAttr("table_ids", tableIds)
+  op.setAttr("max_sequence_lengths", maxSequenceLengths)
+  let _ = op.addInputList(sampleIndices)
+  let _ = op.addInputList(embeddingIndices)
+  let _ = op.addInputList(aggregationWeights)
+  let _ = op.addInput(modeOverride)
+  op.execute()
+}
+
+/// Ensures that the tensor's shape matches the expected shape.
+///
+/// Raises an error if the input tensor's shape does not match the specified shape.
+/// Returns the input tensor otherwise.
+///
+/// - Parameter input: A tensor, whose shape is to be validated.
+///
+/// - Attr shape: The expected (possibly partially specified) shape of the input tensor.
+///
+/// - Output output: A tensor with the same shape and contents as the input tensor or value.
+@inlinable @inline(__always)
+public static func ensureShape<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  shape: TensorShape?
+) -> Tensor<T> {
+  let op = TFE_Op("EnsureShape")
+  op.setAttr("shape", shape)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Creates or finds a child frame, and makes `data` available to the child frame.
+///
+/// This op is used together with `Exit` to create loops in the graph.
+/// The unique `frame_name` is used by the `Executor` to identify frames. If
+/// `is_constant` is true, `output` is a constant in the child frame; otherwise
+/// it may be changed in the child frame. At most `parallel_iterations` iterations
+/// are run in parallel in the child frame.
+///
+/// - Parameter data: The tensor to be made available to the child frame.
+///
+/// - Attrs:
+///   - frame_name: The name of the child frame.
+///   - is_constant: If true, the output is constant within the child frame.
+///   - parallel_iterations: The number of iterations allowed to run in parallel.
+///
+/// - Output output: The same tensor as `data`.
+@inlinable @inline(__always)
+public static func enter<T: TensorFlowScalar>(
+  data: Tensor<T>,
+  frameName: String,
+  isConstant: Bool = false,
+  parallelIterations: Int64 = 10
+) -> Tensor<T> {
+  let op = TFE_Op("Enter")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("frame_name", frameName)
+  op.setAttr("is_constant", isConstant)
+  op.setAttr("parallel_iterations", parallelIterations)
+  let _ = op.addInput(data)
+  return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x == y) element-wise.
+///
+/// *NOTE*: `Equal` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func equal<T: TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<Bool> {
+  let op = TFE_Op("Equal")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x == y) element-wise.
+///
+/// *NOTE*: `Equal` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func equal(
+  _ x: StringTensor,
+  _ y: StringTensor
+) -> Tensor<Bool> {
+  let op = TFE_Op("Equal")
+  op.setAttr("T", TensorDataType(TF_STRING))
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Computes the Gauss error function of `x` element-wise.
+@inlinable @inline(__always)
+public static func erf<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Erf")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the complementary error function of `x` element-wise.
+@inlinable @inline(__always)
+public static func erfc<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Erfc")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the euclidean norm of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///   - input: The tensor to reduce.
+///   - reduction_indices: The dimensions to reduce. Must be in the range
+///     `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func euclideanNorm<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  reductionIndices: Tensor<Tidx>,
+  keepDims: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("EuclideanNorm")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(reductionIndices)
+  return op.execute(Int(1))
+}
+
+/// Exits the current frame to its parent frame.
+///
+/// Exit makes its input `data` available to the parent frame.
+///
+/// - Parameter data: The tensor to be made available to the parent frame.
+///
+/// - Output output: The same tensor as `data`.
+@inlinable @inline(__always)
+public static func exit<T: TensorFlowScalar>(
+  data: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Exit")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(data)
+  return op.execute(Int(1))
+}
+
+/// Computes exponential of x element-wise.  \\(y = e^x\\).
+@inlinable @inline(__always)
+public static func exp<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Exp")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Inserts a dimension of 1 into a tensor's shape.
+///
+/// Given a tensor `input`, this operation inserts a dimension of 1 at the
+/// dimension index `axis` of `input`'s shape. The dimension index `axis` starts at
+/// zero; if you specify a negative number for `axis` it is counted backward from
+/// the end.
+///
+/// This operation is useful if you want to add a batch dimension to a single
+/// element. For example, if you have a single image of shape `[height, width,
+/// channels]`, you can make it a batch of 1 image with `expand_dims(image, 0)`,
+/// which will make the shape `[1, height, width, channels]`.
+///
+/// Other examples:
+///
+/// ```
+/// # 't' is a tensor of shape [2]
+/// shape(expand_dims(t, 0)) ==> [1, 2]
+/// shape(expand_dims(t, 1)) ==> [2, 1]
+/// shape(expand_dims(t, -1)) ==> [2, 1]
+///
+/// # 't2' is a tensor of shape [2, 3, 5]
+/// shape(expand_dims(t2, 0)) ==> [1, 2, 3, 5]
+/// shape(expand_dims(t2, 2)) ==> [2, 3, 1, 5]
+/// shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]
+/// ```
+///
+/// This operation requires that:
+///
+/// `-1-input.dims() <= dim <= input.dims()`
+///
+/// This operation is related to `squeeze()`, which removes dimensions of
+/// size 1.
+///
+/// - Parameter dim: 0-D (scalar). Specifies the dimension index at which to
+///   expand the shape of `input`. Must be in the range
+///   `[-rank(input) - 1, rank(input)]`.
+///
+/// - Output output: Contains the same data as `input`, but its shape has an additional
+///   dimension of size 1 added.
+@inlinable @inline(__always)
+public static func expandDims<
+    T: TensorFlowScalar,
+    Tdim: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  dim: Tensor<Tdim>
+) -> Tensor<T> {
+  let op = TFE_Op("ExpandDims")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tdim", Tdim.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(dim)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalAssertNextDataset(
+  inputDataset: VariantHandle,
+  transformations: StringTensor,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalAssertNextDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(transformations)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that shards the input dataset.
+///
+/// Creates a dataset that shards the input dataset by num_workers, returning a
+/// sharded dataset for the index-th worker. This attempts to automatically shard
+/// a dataset by examining the Dataset graph and inserting a shard op before the
+/// inputs to a reader Dataset (e.g. CSVDataset, TFRecordDataset).
+///
+/// This dataset will throw a NotFound error if we cannot shard the dataset
+/// automatically.
+///
+/// - Parameters:
+///   - input_dataset: A variant tensor representing the input dataset.
+///   - num_workers: A scalar representing the number of workers to distribute this dataset across.
+///   - index: A scalar representing the index of the current worker out of num_workers.
+@inlinable @inline(__always)
+public static func experimentalAutoShardDataset(
+  inputDataset: VariantHandle,
+  numWorkers: Tensor<Int64>,
+  index: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalAutoShardDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(numWorkers)
+  let _ = op.addInput(index)
+  return op.execute(Int(1))
+}
+
+/// Records the bytes size of each element of `input_dataset` in a StatsAggregator.
+@inlinable @inline(__always)
+public static func experimentalBytesProducedStatsDataset(
+  inputDataset: VariantHandle,
+  tag: StringTensor,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalBytesProducedStatsDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(tag)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalCSVDataset<OutputTypes: TensorArrayProtocol>(
+  filenames: StringTensor,
+  compressionType: StringTensor,
+  bufferSize: Tensor<Int64>,
+  header: Tensor<Bool>,
+  fieldDelim: StringTensor,
+  useQuoteDelim: Tensor<Bool>,
+  naValue: StringTensor,
+  selectCols: Tensor<Int64>,
+  recordDefaults: OutputTypes,
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalCSVDataset")
+  op.setAttr("output_types", recordDefaults._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(filenames)
+  let _ = op.addInput(compressionType)
+  let _ = op.addInput(bufferSize)
+  let _ = op.addInput(header)
+  let _ = op.addInput(fieldDelim)
+  let _ = op.addInput(useQuoteDelim)
+  let _ = op.addInput(naValue)
+  let _ = op.addInput(selectCols)
+  let _ = op.addInputList(recordDefaults)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalChooseFastestDataset(
+  inputDatasets: [VariantHandle],
+  numExperiments: Int64,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalChooseFastestDataset")
+  op.setAttr("N", inputDatasets.count)
+  op.setAttr("num_experiments", numExperiments)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInputList(inputDatasets)
+  return op.execute(Int(1))
+}
+
+/// Returns the cardinality of `input_dataset`.
+///
+/// Returns the cardinality of `input_dataset`.
+///
+/// - Parameter input_dataset: A variant tensor representing the dataset to return cardinality for.
+///
+/// - Output cardinality: The cardinality of `input_dataset`. Named constants are used to represent
+///   infinite and unknown cardinality.
+@inlinable @inline(__always)
+public static func experimentalDatasetCardinality(
+  inputDataset: VariantHandle
+) -> Tensor<Int64> {
+  let op = TFE_Op("ExperimentalDatasetCardinality")
+  let _ = op.addInput(inputDataset)
+  return op.execute(Int(1))
+}
+
+/// Writes the given dataset to the given file using the TFRecord format.
+///
+/// - Parameters:
+///   - input_dataset: A variant tensor representing the dataset to write.
+///   - filename: A scalar string tensor representing the filename to use.
+///   - compression_type: A scalar string tensor containing either (i) the empty string (no
+///     compression), (ii) "ZLIB", or (iii) "GZIP".
+@inlinable @inline(__always)
+public static func experimentalDatasetToTFRecord(
+  inputDataset: VariantHandle,
+  filename: StringTensor,
+  compressionType: StringTensor
+) {
+  let op = TFE_Op("ExperimentalDatasetToTFRecord")
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(filename)
+  let _ = op.addInput(compressionType)
+  op.execute()
+}
+
+/// Creates a dataset that batches input elements into a SparseTensor.
+///
+/// - Parameters:
+///   - input_dataset: A handle to an input dataset. Must have a single component.
+///   - batch_size: A scalar representing the number of elements to accumulate in a
+///     batch.
+///   - row_shape: A vector representing the dense shape of each row in the produced
+///     SparseTensor. The shape may be partially specified, using `-1` to indicate
+///     that a particular dimension should use the maximum size of all batch elements.
+@inlinable @inline(__always)
+public static func experimentalDenseToSparseBatchDataset(
+  inputDataset: VariantHandle,
+  batchSize: Tensor<Int64>,
+  rowShape: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalDenseToSparseBatchDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(batchSize)
+  let _ = op.addInput(rowShape)
+  return op.execute(Int(1))
+}
+
+/// A substitute for `InterleaveDataset` on a fixed list of `N` datasets.
+///
+/// - Parameters:
+///   - selector_input_dataset: A dataset of scalar `DT_INT64` elements that determines which of the
+///     `N` data inputs should produce the next output element.
+///   - data_input_datasets: `N` datasets with the same type that will be interleaved according to
+///     the values of `selector_input_dataset`.
+@inlinable @inline(__always)
+public static func experimentalDirectedInterleaveDataset(
+  selectorInputDataset: VariantHandle,
+  dataInputDatasets: [VariantHandle],
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalDirectedInterleaveDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("N", dataInputDatasets.count)
+  let _ = op.addInput(selectorInputDataset)
+  let _ = op.addInputList(dataInputDatasets)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that computes a group-by on `input_dataset`.
+///
+/// Creates a dataset that computes a group-by on `input_dataset`.
+///
+/// - Parameters:
+///   - input_dataset: A variant tensor representing the input dataset.
+///   - key_func_other_arguments: A list of tensors, typically values that were captured when
+///     building a closure for `key_func`.
+///   - init_func_other_arguments: A list of tensors, typically values that were captured when
+///     building a closure for `init_func`.
+///   - reduce_func_other_arguments: A list of tensors, typically values that were captured when
+///     building a closure for `reduce_func`.
+///   - finalize_func_other_arguments: A list of tensors, typically values that were captured when
+///     building a closure for `finalize_func`.
+///
+/// - Attrs:
+///   - key_func: A function mapping an element of `input_dataset`, concatenated
+///     with `key_func_other_arguments` to a scalar value of type DT_INT64.
+///   - init_func: A function mapping a key of type DT_INT64, concatenated with
+///     `init_func_other_arguments` to the initial reducer state.
+///   - reduce_func: A function mapping the current reducer state and an element of `input_dataset`,
+///     concatenated with `reduce_func_other_arguments` to a new reducer state.
+///   - finalize_func: A function mapping the final reducer state to an output element.
+@inlinable @inline(__always)
+public static func experimentalGroupByReducerDataset<
+    KeyfuncIn: TensorGroup,
+    KeyfuncOut: TensorGroup,
+    InitfuncIn: TensorGroup,
+    InitfuncOut: TensorGroup,
+    ReducefuncIn: TensorGroup,
+    ReducefuncOut: TensorGroup,
+    FinalizefuncIn: TensorGroup,
+    FinalizefuncOut: TensorGroup,
+    TkeyFuncOtherArguments: TensorArrayProtocol,
+    TinitFuncOtherArguments: TensorArrayProtocol,
+    TreduceFuncOtherArguments: TensorArrayProtocol,
+    TfinalizeFuncOtherArguments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  keyFuncOtherArguments: TkeyFuncOtherArguments,
+  initFuncOtherArguments: TinitFuncOtherArguments,
+  reduceFuncOtherArguments: TreduceFuncOtherArguments,
+  finalizeFuncOtherArguments: TfinalizeFuncOtherArguments,
+  keyFunc: (KeyfuncIn) -> KeyfuncOut,
+  initFunc: (InitfuncIn) -> InitfuncOut,
+  reduceFunc: (ReducefuncIn) -> ReducefuncOut,
+  finalizeFunc: (FinalizefuncIn) -> FinalizefuncOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalGroupByReducerDataset")
+  op.setAttr("key_func", keyFunc)
+  op.setAttr("init_func", initFunc)
+  op.setAttr("reduce_func", reduceFunc)
+  op.setAttr("finalize_func", finalizeFunc)
+  op.setAttr("Tkey_func_other_arguments", keyFuncOtherArguments._typeList)
+  op.setAttr("Tinit_func_other_arguments", initFuncOtherArguments._typeList)
+  op.setAttr("Treduce_func_other_arguments", reduceFuncOtherArguments._typeList)
+  op.setAttr("Tfinalize_func_other_arguments", finalizeFuncOtherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(keyFuncOtherArguments)
+  let _ = op.addInputList(initFuncOtherArguments)
+  let _ = op.addInputList(reduceFuncOtherArguments)
+  let _ = op.addInputList(finalizeFuncOtherArguments)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that computes a windowed group-by on `input_dataset`.
+///
+/// // TODO(mrry): Support non-int64 keys.
+///
+/// - Attr key_func: A function mapping an element of `input_dataset`, concatenated
+///   with `key_func_other_arguments` to a scalar value of type DT_INT64.
+@inlinable @inline(__always)
+public static func experimentalGroupByWindowDataset<
+    KeyfuncIn: TensorGroup,
+    KeyfuncOut: TensorGroup,
+    ReducefuncIn: TensorGroup,
+    ReducefuncOut: TensorGroup,
+    WindowsizefuncIn: TensorGroup,
+    WindowsizefuncOut: TensorGroup,
+    TkeyFuncOtherArguments: TensorArrayProtocol,
+    TreduceFuncOtherArguments: TensorArrayProtocol,
+    TwindowSizeFuncOtherArguments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  keyFuncOtherArguments: TkeyFuncOtherArguments,
+  reduceFuncOtherArguments: TreduceFuncOtherArguments,
+  windowSizeFuncOtherArguments: TwindowSizeFuncOtherArguments,
+  keyFunc: (KeyfuncIn) -> KeyfuncOut,
+  reduceFunc: (ReducefuncIn) -> ReducefuncOut,
+  windowSizeFunc: (WindowsizefuncIn) -> WindowsizefuncOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalGroupByWindowDataset")
+  op.setAttr("key_func", keyFunc)
+  op.setAttr("reduce_func", reduceFunc)
+  op.setAttr("window_size_func", windowSizeFunc)
+  op.setAttr("Tkey_func_other_arguments", keyFuncOtherArguments._typeList)
+  op.setAttr("Treduce_func_other_arguments", reduceFuncOtherArguments._typeList)
+  op.setAttr("Twindow_size_func_other_arguments", windowSizeFuncOtherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(keyFuncOtherArguments)
+  let _ = op.addInputList(reduceFuncOtherArguments)
+  let _ = op.addInputList(windowSizeFuncOtherArguments)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalIdentityIndexedDataset(
+  size: Tensor<UInt64>
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalIdentityIndexedDataset")
+  let _ = op.addInput(size)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that contains the elements of `input_dataset` ignoring errors.
+@inlinable @inline(__always)
+public static func experimentalIgnoreErrorsDataset(
+  inputDataset: VariantHandle,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalIgnoreErrorsDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalIndexedDatasetGet<OutputTypes: TensorGroup>(
+  materialized: ResourceHandle,
+  index: Tensor<UInt64>,
+  outputShapes: [TensorShape?]
+) -> OutputTypes {
+  let op = TFE_Op("ExperimentalIndexedDatasetGet")
+  op.setAttr("output_types", OutputTypes._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(materialized)
+  let _ = op.addInput(index)
+  return op.execute(Int(OutputTypes._typeList.count))
+}
+
+@inlinable @inline(__always)
+public static func experimentalIndexedDatasetMaterialize(
+  dataset: VariantHandle,
+  materialized: ResourceHandle
+) {
+  let op = TFE_Op("ExperimentalIndexedDatasetMaterialize")
+  let _ = op.addInput(dataset)
+  let _ = op.addInput(materialized)
+  op.execute()
+}
+
+/// Returns the name of the device on which `resource` has been placed.
+@inlinable @inline(__always)
+public static func experimentalIteratorGetDevice(
+  resource: ResourceHandle
+) -> StringTensor {
+  let op = TFE_Op("ExperimentalIteratorGetDevice")
+  let _ = op.addInput(resource)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalLMDBDataset(
+  filenames: StringTensor,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalLMDBDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(filenames)
+  return op.execute(Int(1))
+}
+
+/// Records the latency of producing `input_dataset` elements in a StatsAggregator.
+@inlinable @inline(__always)
+public static func experimentalLatencyStatsDataset(
+  inputDataset: VariantHandle,
+  tag: StringTensor,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalLatencyStatsDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(tag)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that fuses mapping with batching.
+///
+/// Creates a dataset that applies `f` to the outputs of `input_dataset` and then
+/// batches `batch_size` of them.
+///
+/// Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
+/// to `batch_size * num_parallel_batches` copies of `f` in parallel.
+///
+/// - Parameters:
+///   - input_dataset: A variant tensor representing the input dataset.
+///   - other_arguments: A list of tensors, typically values that were captured when building a closure
+///     for `f`.
+///   - batch_size: A scalar representing the number of elements to accumulate in a
+///     batch. It determines the number of concurrent invocations of `f` that process
+///     elements from `input_dataset` in parallel.
+///   - num_parallel_calls: A scalar representing the maximum number of parallel invocations of the `map_fn`
+///     function. Applying the `map_fn` on consecutive input elements in parallel has
+///     the potential to improve input pipeline throughput.
+///   - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
+///     is smaller than desired.
+///
+/// - Attr f: A function to apply to the outputs of `input_dataset`.
+@inlinable @inline(__always)
+public static func experimentalMapAndBatchDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  otherArguments: Targuments,
+  batchSize: Tensor<Int64>,
+  numParallelCalls: Tensor<Int64>,
+  dropRemainder: Tensor<Bool>,
+  f: (FIn) -> FOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?],
+  preserveCardinality: Bool = false
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalMapAndBatchDataset")
+  op.setAttr("f", f)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("preserve_cardinality", preserveCardinality)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(otherArguments)
+  let _ = op.addInput(batchSize)
+  let _ = op.addInput(numParallelCalls)
+  let _ = op.addInput(dropRemainder)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+@inlinable @inline(__always)
+public static func experimentalMapDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  otherArguments: Targuments,
+  f: (FIn) -> FOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?],
+  useInterOpParallelism: Bool = true,
+  preserveCardinality: Bool = false
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalMapDataset")
+  op.setAttr("f", f)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("use_inter_op_parallelism", useInterOpParallelism)
+  op.setAttr("preserve_cardinality", preserveCardinality)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(otherArguments)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalMatchingFilesDataset(
+  patterns: StringTensor
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalMatchingFilesDataset")
+  let _ = op.addInput(patterns)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalMaterializedIndexDatasetHandle(
+  container: String,
+  sharedName: String,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let op = TFE_Op("ExperimentalMaterializedIndexDatasetHandle")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that overrides the maximum intra-op parallelism.
+///
+/// - Parameter max_intra_op_parallelism: Identifies the maximum intra-op parallelism to use.
+@inlinable @inline(__always)
+public static func experimentalMaxIntraOpParallelismDataset(
+  inputDataset: VariantHandle,
+  maxIntraOpParallelism: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalMaxIntraOpParallelismDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(maxIntraOpParallelism)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalNonSerializableDataset(
+  inputDataset: VariantHandle,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalNonSerializableDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that fuses mapping with batching.
+///
+/// Creates a dataset that applies `f` to the outputs of `input_dataset` and then
+/// batches `batch_size` of them.
+///
+/// Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
+/// to `batch_size * num_parallel_batches` copies of `f` in parallel.
+///
+/// Unlike "MapAndBatchDatasetV2", this dataset uses a NUMA-aware thread scheduling
+/// policy. Because it uses the single-threaded executor, it only supports the
+/// function-based control flow ops.
+///
+/// - Parameters:
+///   - input_dataset: A variant tensor representing the input dataset.
+///   - other_arguments: A list of tensors, typically values that were captured when building a closure
+///     for `f`.
+///   - batch_size: A scalar representing the number of elements to accumulate in a
+///     batch. It determines the number of concurrent invocations of `f` that process
+///     elements from `input_dataset` in parallel.
+///   - num_parallel_calls: A scalar representing the maximum number of parallel invocations of the `map_fn`
+///     function. Applying the `map_fn` on consecutive input elements in parallel has
+///     the potential to improve input pipeline throughput.
+///   - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
+///     is smaller than desired.
+///
+/// - Attr f: A function to apply to the outputs of `input_dataset`.
+@inlinable @inline(__always)
+public static func experimentalNumaMapAndBatchDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  otherArguments: Targuments,
+  batchSize: Tensor<Int64>,
+  numParallelCalls: Tensor<Int64>,
+  dropRemainder: Tensor<Bool>,
+  f: (FIn) -> FOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?],
+  preserveCardinality: Bool = false
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalNumaMapAndBatchDataset")
+  op.setAttr("f", f)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("preserve_cardinality", preserveCardinality)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(otherArguments)
+  let _ = op.addInput(batchSize)
+  let _ = op.addInput(numParallelCalls)
+  let _ = op.addInput(dropRemainder)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+///
+/// The resulting dataset is similar to the `InterleaveDataset`, with the exception
+/// that if retrieving the next value from a dataset would cause the requester to
+/// block, it will skip that input dataset. This dataset is especially useful
+/// when loading data from a variable-latency datastores (e.g. HDFS, GCS), as it
+/// allows the training step to proceed so long as some data is available.
+///
+/// !! WARNING !! This dataset is not deterministic!
+///
+/// - Attr f: A function mapping elements of `input_dataset`, concatenated with
+///   `other_arguments`, to a Dataset variant that contains elements matching
+///   `output_types` and `output_shapes`.
+@inlinable @inline(__always)
+public static func experimentalParallelInterleaveDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  otherArguments: Targuments,
+  cycleLength: Tensor<Int64>,
+  blockLength: Tensor<Int64>,
+  sloppy: Tensor<Bool>,
+  bufferOutputElements: Tensor<Int64>,
+  prefetchInputElements: Tensor<Int64>,
+  f: (FIn) -> FOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalParallelInterleaveDataset")
+  op.setAttr("f", f)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(otherArguments)
+  let _ = op.addInput(cycleLength)
+  let _ = op.addInput(blockLength)
+  let _ = op.addInput(sloppy)
+  let _ = op.addInput(bufferOutputElements)
+  let _ = op.addInput(prefetchInputElements)
+  return op.execute(Int(1))
+}
+
+/// Transforms `input_dataset` containing `Example` protos as vectors of DT_STRING into a dataset of `Tensor` or `SparseTensor` objects representing the parsed features.
+///
+/// - Parameter dense_defaults: A dict mapping string keys to `Tensor`s.
+///   The keys of the dict must match the dense_keys of the feature.
+///
+/// - Attrs:
+///   - sparse_keys: A list of string keys in the examples features.
+///     The results for these keys will be returned as `SparseTensor` objects.
+///   - dense_keys: A list of Ndense string Tensors (scalars).
+///     The keys expected in the Examples features associated with dense values.
+///   - sparse_types: A list of `DTypes` of the same length as `sparse_keys`.
+///     Only `tf.float32` (`FloatList`), `tf.int64` (`Int64List`),
+///     and `tf.string` (`BytesList`) are supported.
+///   - Tdense: A list of DTypes of the same length as `dense_keys`.
+///     Only `tf.float32` (`FloatList`), `tf.int64` (`Int64List`),
+///     and `tf.string` (`BytesList`) are supported.
+///
+///   - dense_shapes: List of tuples with the same length as `dense_keys`.
+///     The shape of the data for each dense feature referenced by `dense_keys`.
+///     Required for any input tensors identified by `dense_keys`.  Must be
+///     either fully defined, or may contain an unknown first dimension.
+///     An unknown first dimension means the feature is treated as having
+///     a variable number of blocks, and the output shape along this dimension
+///     is considered unknown at graph build time.  Padding is applied for
+///     minibatch elements smaller than the maximum number of blocks for the
+///     given feature along this dimension.
+///   - output_types: The type list for the return values.
+///   - output_shapes: The list of shapes being produced.
+@inlinable @inline(__always)
+public static func experimentalParseExampleDataset<Tdense: TensorArrayProtocol>(
+  inputDataset: VariantHandle,
+  numParallelCalls: Tensor<Int64>,
+  denseDefaults: Tdense,
+  sparseKeys: [String],
+  denseKeys: [String],
+  sparseTypes: [TensorDataType],
+  denseShapes: [TensorShape?],
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?],
+  sloppy: Bool = false
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalParseExampleDataset")
+  op.setAttr("sparse_keys", sparseKeys)
+  op.setAttr("dense_keys", denseKeys)
+  op.setAttr("sparse_types", sparseTypes)
+  op.setAttr("Tdense", denseDefaults._typeList)
+  op.setAttr("dense_shapes", denseShapes)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("sloppy", sloppy)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(numParallelCalls)
+  let _ = op.addInputList(denseDefaults)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that uses a custom thread pool to compute `input_dataset`.
+///
+/// - Parameter num_threads: Identifies the number of threads to use for the private threadpool.
+@inlinable @inline(__always)
+public static func experimentalPrivateThreadPoolDataset(
+  inputDataset: VariantHandle,
+  numThreads: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalPrivateThreadPoolDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(numThreads)
+  return op.execute(Int(1))
+}
+
+/// Creates a Dataset that returns pseudorandom numbers.
+///
+/// - Parameters:
+///   - seed: A scalar seed for the random number generator. If either seed or
+///     seed2 is set to be non-zero, the random number generator is seeded
+///     by the given seed.  Otherwise, a random seed is used.
+///   - seed2: A second scalar seed to avoid seed collision.
+@inlinable @inline(__always)
+public static func experimentalRandomDataset(
+  seed: Tensor<Int64>,
+  seed2: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalRandomDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(seed)
+  let _ = op.addInput(seed2)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that changes the batch size.
+///
+/// Creates a dataset that changes the batch size of the dataset to current batch
+/// size // num_workers.
+///
+/// - Parameters:
+///   - input_dataset: A variant tensor representing the input dataset.
+///   - num_workers: A scalar representing the number of workers to distribute this batch across. As
+///     a result of this transformation the current batch size would end up being
+///     divided  by this parameter.
+@inlinable @inline(__always)
+public static func experimentalRebatchDataset(
+  inputDataset: VariantHandle,
+  numWorkers: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalRebatchDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(numWorkers)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset successively reduces `f` over the elements of `input_dataset`.
+@inlinable @inline(__always)
+public static func experimentalScanDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Tstate: TensorArrayProtocol,
+    Targuments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  initialState: Tstate,
+  otherArguments: Targuments,
+  f: (FIn) -> FOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?],
+  preserveCardinality: Bool = false
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalScanDataset")
+  op.setAttr("f", f)
+  op.setAttr("Tstate", initialState._typeList)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("preserve_cardinality", preserveCardinality)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(initialState)
+  let _ = op.addInputList(otherArguments)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalSetStatsAggregatorDataset(
+  inputDataset: VariantHandle,
+  statsAggregator: ResourceHandle,
+  tag: StringTensor,
+  counterPrefix: StringTensor,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalSetStatsAggregatorDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(statsAggregator)
+  let _ = op.addInput(tag)
+  let _ = op.addInput(counterPrefix)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalSleepDataset(
+  inputDataset: VariantHandle,
+  sleepMicroseconds: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalSleepDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(sleepMicroseconds)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that passes a sliding window over `input_dataset`.
+///
+/// - Parameters:
+///   - window_size: A scalar representing the number of elements in the
+///     sliding window.
+///   - window_shift: A scalar representing the steps moving the sliding window
+///     forward in one iteration. It must be positive.
+///   - window_stride: A scalar representing the stride of the input elements of the sliding window.
+///     It must be positive.
+@inlinable @inline(__always)
+public static func experimentalSlidingWindowDataset(
+  inputDataset: VariantHandle,
+  windowSize: Tensor<Int64>,
+  windowShift: Tensor<Int64>,
+  windowStride: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalSlidingWindowDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(windowSize)
+  let _ = op.addInput(windowShift)
+  let _ = op.addInput(windowStride)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that executes a SQL query and emits rows of the result set.
+///
+/// - Parameters:
+///   - driver_name: The database type. Currently, the only supported type is 'sqlite'.
+///   - data_source_name: A connection string to connect to the database.
+///   - query: A SQL query to execute.
+@inlinable @inline(__always)
+public static func experimentalSqlDataset(
+  driverName: StringTensor,
+  dataSourceName: StringTensor,
+  query: StringTensor,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalSqlDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(driverName)
+  let _ = op.addInput(dataSourceName)
+  let _ = op.addInput(query)
+  return op.execute(Int(1))
+}
+
+/// Creates a statistics manager resource.
+@inlinable @inline(__always)
+public static func experimentalStatsAggregatorHandle(
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("ExperimentalStatsAggregatorHandle")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Produces a summary of any statistics recorded by the given statistics manager.
+@inlinable @inline(__always)
+public static func experimentalStatsAggregatorSummary(
+  iterator: ResourceHandle
+) -> StringTensor {
+  let op = TFE_Op("ExperimentalStatsAggregatorSummary")
+  let _ = op.addInput(iterator)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that stops iteration when predicate` is false.
+///
+/// The `predicate` function must return a scalar boolean and accept the
+/// following arguments:
+///
+/// * One tensor for each component of an element of `input_dataset`.
+/// * One tensor for each value in `other_arguments`.
+///
+/// - Parameter other_arguments: A list of tensors, typically values that were captured when
+///   building a closure for `predicate`.
+///
+/// - Attr predicate: A function returning a scalar boolean.
+@inlinable @inline(__always)
+public static func experimentalTakeWhileDataset<
+    PredicateIn: TensorGroup,
+    PredicateOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  otherArguments: Targuments,
+  predicate: (PredicateIn) -> PredicateOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalTakeWhileDataset")
+  op.setAttr("predicate", predicate)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(otherArguments)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that uses a custom thread pool to compute `input_dataset`.
+///
+/// - Parameter thread_pool: A resource produced by the ThreadPoolHandle op.
+@inlinable @inline(__always)
+public static func experimentalThreadPoolDataset(
+  inputDataset: VariantHandle,
+  threadPool: ResourceHandle,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalThreadPoolDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(threadPool)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that uses a custom thread pool to compute `input_dataset`.
+///
+/// - Attrs:
+///   - num_threads: The number of threads in the thread pool.
+///   - max_intra_op_parallelism: The maximum degree of parallelism to use within operations that execute on this
+///     threadpool.
+///   - display_name: A human-readable name for the threads that may be visible in some
+///     visualizations.
+///     threadpool.
+///
+/// - Output handle: A resource that can be consumed by one or more ExperimentalThreadPoolDataset
+///   ops.
+@inlinable @inline(__always)
+public static func experimentalThreadPoolHandle(
+  numThreads: Int64,
+  maxIntraOpParallelism: Int64 = 1,
+  displayName: String,
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("ExperimentalThreadPoolHandle")
+  op.setAttr("num_threads", numThreads)
+  op.setAttr("max_intra_op_parallelism", maxIntraOpParallelism)
+  op.setAttr("display_name", displayName)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// A dataset that splits the elements of its input into multiple elements.
+@inlinable @inline(__always)
+public static func experimentalUnbatchDataset(
+  inputDataset: VariantHandle,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalUnbatchDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that contains the unique elements of `input_dataset`.
+@inlinable @inline(__always)
+public static func experimentalUniqueDataset(
+  inputDataset: VariantHandle,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ExperimentalUniqueDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  return op.execute(Int(1))
+}
+
+/// Computes exponential of x - 1 element-wise.
+///
+/// I.e., \\(y = (\exp x) - 1\\).
+@inlinable @inline(__always)
+public static func expm1<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Expm1")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Extracts a glimpse from the input tensor.
+///
+/// Returns a set of windows called glimpses extracted at location
+/// `offsets` from the input tensor. If the windows only partially
+/// overlaps the inputs, the non overlapping areas will be filled with
+/// random noise.
+///
+/// The result is a 4-D tensor of shape `[batch_size, glimpse_height,
+/// glimpse_width, channels]`. The channels and batch dimensions are the
+/// same as that of the input tensor. The height and width of the output
+/// windows are specified in the `size` parameter.
+///
+/// The argument `normalized` and `centered` controls how the windows are built:
+///
+/// * If the coordinates are normalized but not centered, 0.0 and 1.0
+///   correspond to the minimum and maximum of each height and width
+///   dimension.
+/// * If the coordinates are both normalized and centered, they range from
+///   -1.0 to 1.0. The coordinates (-1.0, -1.0) correspond to the upper
+///   left corner, the lower right corner is located at (1.0, 1.0) and the
+///   center is at (0, 0).
+/// * If the coordinates are not normalized they are interpreted as
+///   numbers of pixels.
+///
+/// - Parameters:
+///   - input: A 4-D float tensor of shape `[batch_size, height, width, channels]`.
+///   - size: A 1-D tensor of 2 elements containing the size of the glimpses
+///     to extract.  The glimpse height must be specified first, following
+///     by the glimpse width.
+///   - offsets: A 2-D integer tensor of shape `[batch_size, 2]` containing
+///     the y, x locations of the center of each window.
+///
+/// - Attrs:
+///   - centered: indicates if the offset coordinates are centered relative to
+///     the image, in which case the (0, 0) offset is relative to the center
+///     of the input images. If false, the (0,0) offset corresponds to the
+///     upper left corner of the input images.
+///   - normalized: indicates if the offset coordinates are normalized.
+///   - uniform_noise: indicates if the noise should be generated using a
+///     uniform distribution or a Gaussian distribution.
+///   - noise: indicates if the noise should `uniform`, `gaussian`, or
+///     `zero`. The default is `uniform` which means the the noise type
+///     will be decided by `uniform_noise`.
+///
+/// - Output glimpse: A tensor representing the glimpses `[batch_size,
+///   glimpse_height, glimpse_width, channels]`.
+@inlinable @inline(__always)
+public static func extractGlimpse(
+  _ input: Tensor<Float>,
+  size: Tensor<Int32>,
+  offsets: Tensor<Float>,
+  centered: Bool = true,
+  normalized: Bool = true,
+  uniformNoise: Bool = true,
+  noise: String = "uniform"
+) -> Tensor<Float> {
+  let op = TFE_Op("ExtractGlimpse")
+  op.setAttr("centered", centered)
+  op.setAttr("normalized", normalized)
+  op.setAttr("uniform_noise", uniformNoise)
+  op.setAttr("noise", noise)
+  let _ = op.addInput(input)
+  let _ = op.addInput(size)
+  let _ = op.addInput(offsets)
+  return op.execute(Int(1))
+}
+
+/// Extract `patches` from `images` and put them in the "depth" output dimension.
+///
+/// - Parameter images: 4-D Tensor with shape `[batch, in_rows, in_cols, depth]`.
+///
+/// - Attrs:
+///   - ksizes: The size of the sliding window for each dimension of `images`.
+///   - strides: 1-D of length 4. How far the centers of two consecutive patches are in
+///     the images. Must be: `[1, stride_rows, stride_cols, 1]`.
+///   - rates: 1-D of length 4. Must be: `[1, rate_rows, rate_cols, 1]`. This is the
+///     input stride, specifying how far two consecutive patch samples are in the
+///     input. Equivalent to extracting patches with
+///     `patch_sizes_eff = patch_sizes + (patch_sizes - 1) * (rates - 1)`, followed by
+///     subsampling them spatially by a factor of `rates`. This is equivalent to
+///     `rate` in dilated (a.k.a. Atrous) convolutions.
+///   - padding: The type of padding algorithm to use.
+///
+///     We specify the size-related attributes as:
+///
+///     ```python
+///           ksizes = [1, ksize_rows, ksize_cols, 1]
+///           strides = [1, strides_rows, strides_cols, 1]
+///           rates = [1, rates_rows, rates_cols, 1]
+///     ```
+///
+/// - Output patches: 4-D Tensor with shape `[batch, out_rows, out_cols, ksize_rows *
+///   ksize_cols * depth]` containing image patches with size
+///   `ksize_rows x ksize_cols x depth` vectorized in the "depth" dimension. Note
+///   `out_rows` and `out_cols` are the dimensions of the output patches.
+@inlinable @inline(__always)
+public static func extractImagePatches<T: Numeric & TensorFlowScalar>(
+  images: Tensor<T>,
+  ksizes: [Int32],
+  strides: [Int32],
+  rates: [Int32],
+  padding: Padding
+) -> Tensor<T> {
+  let op = TFE_Op("ExtractImagePatches")
+  op.setAttr("ksizes", ksizes)
+  op.setAttr("strides", strides)
+  op.setAttr("rates", rates)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("padding", padding.cName)
+  let _ = op.addInput(images)
+  return op.execute(Int(1))
+}
+
+/// Extract the shape information of a JPEG-encoded image.
+///
+/// This op only parses the image header, so it is much faster than DecodeJpeg.
+///
+/// - Parameter contents: 0-D. The JPEG-encoded image.
+///
+/// - Attr output_type: (Optional) The output type of the operation (int32 or int64).
+///   Defaults to int32.
+///
+/// - Output image_shape: 1-D. The image shape with format [height, width, channels].
+@inlinable @inline(__always)
+public static func extractJpegShape<OutputType: BinaryInteger & TensorFlowScalar>(
+  contents: StringTensor
+) -> Tensor<OutputType> {
+  let op = TFE_Op("ExtractJpegShape")
+  op.setAttr("output_type", OutputType.tensorFlowDataType)
+  let _ = op.addInput(contents)
+  return op.execute(Int(1))
+}
+
+/// Extract `patches` from `input` and put them in the "depth" output dimension. 3D extension of `extract_image_patches`.
+///
+/// - Parameter input: 5-D Tensor with shape `[batch, in_planes, in_rows, in_cols, depth]`.
+///
+/// - Attrs:
+///   - ksizes: The size of the sliding window for each dimension of `input`.
+///   - strides: 1-D of length 5. How far the centers of two consecutive patches are in
+///     `input`. Must be: `[1, stride_planes, stride_rows, stride_cols, 1]`.
+///   - padding: The type of padding algorithm to use.
+///
+///     We specify the size-related attributes as:
+///
+///     ```python
+///           ksizes = [1, ksize_planes, ksize_rows, ksize_cols, 1]
+///           strides = [1, stride_planes, strides_rows, strides_cols, 1]
+///     ```
+///
+/// - Output patches: 5-D Tensor with shape `[batch, out_planes, out_rows, out_cols,
+///   ksize_planes * ksize_rows * ksize_cols * depth]` containing patches
+///   with size `ksize_planes x ksize_rows x ksize_cols x depth` vectorized
+///   in the "depth" dimension. Note `out_planes`, `out_rows` and `out_cols`
+///   are the dimensions of the output patches.
+@inlinable @inline(__always)
+public static func extractVolumePatches<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  ksizes: [Int32],
+  strides: [Int32],
+  padding: Padding
+) -> Tensor<T> {
+  let op = TFE_Op("ExtractVolumePatches")
+  op.setAttr("ksizes", ksizes)
+  op.setAttr("strides", strides)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("padding", padding.cName)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Fast Fourier transform.
+///
+/// Computes the 1-dimensional discrete Fourier transform over the inner-most
+/// dimension of `input`.
+///
+/// - Parameter input: A complex tensor.
+///
+/// - Output output: A complex tensor of the same shape as `input`. The inner-most
+///     dimension of `input` is replaced with its 1D Fourier transform.
+///
+///   @compatibility(numpy)
+///   Equivalent to np.fft.fft
+///   @end_compatibility
+@inlinable @inline(__always)
+public static func fFT<Tcomplex: TensorFlowScalar>(
+  _ input: Tensor<Tcomplex>
+) -> Tensor<Tcomplex> {
+  let op = TFE_Op("FFT")
+  op.setAttr("Tcomplex", Tcomplex.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// 2D fast Fourier transform.
+///
+/// Computes the 2-dimensional discrete Fourier transform over the inner-most
+/// 2 dimensions of `input`.
+///
+/// - Parameter input: A complex tensor.
+///
+/// - Output output: A complex tensor of the same shape as `input`. The inner-most 2
+///     dimensions of `input` are replaced with their 2D Fourier transform.
+///
+///   @compatibility(numpy)
+///   Equivalent to np.fft.fft2
+///   @end_compatibility
+@inlinable @inline(__always)
+public static func fFT2D<Tcomplex: TensorFlowScalar>(
+  _ input: Tensor<Tcomplex>
+) -> Tensor<Tcomplex> {
+  let op = TFE_Op("FFT2D")
+  op.setAttr("Tcomplex", Tcomplex.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// 3D fast Fourier transform.
+///
+/// Computes the 3-dimensional discrete Fourier transform over the inner-most 3
+/// dimensions of `input`.
+///
+/// - Parameter input: A complex64 tensor.
+///
+/// - Output output: A complex64 tensor of the same shape as `input`. The inner-most 3
+///     dimensions of `input` are replaced with their 3D Fourier transform.
+///
+///   @compatibility(numpy)
+///   Equivalent to np.fft.fftn with 3 dimensions.
+///   @end_compatibility
+@inlinable @inline(__always)
+public static func fFT3D<Tcomplex: TensorFlowScalar>(
+  _ input: Tensor<Tcomplex>
+) -> Tensor<Tcomplex> {
+  let op = TFE_Op("FFT3D")
+  op.setAttr("Tcomplex", Tcomplex.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// A queue that produces elements in first-in first-out order.
+///
+/// - Attrs:
+///   - component_types: The type of each component in a value.
+///   - shapes: The shape of each component in a value. The length of this attr must
+///     be either 0 or the same as the length of component_types. If the length of
+///     this attr is 0, the shapes of queue elements are not constrained, and
+///     only one element may be dequeued at a time.
+///   - capacity: The upper bound on the number of elements in this queue.
+///     Negative numbers mean no limit.
+///   - container: If non-empty, this queue is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this queue will be shared under the given name
+///     across multiple sessions.
+///
+/// - Output handle: The handle to the queue.
+@inlinable @inline(__always)
+public static func fIFOQueueV2(
+  componentTypes: [TensorDataType],
+  shapes: [TensorShape?],
+  capacity: Int64 = -1,
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("FIFOQueueV2")
+  op.setAttr("component_types", componentTypes)
+  op.setAttr("shapes", shapes)
+  op.setAttr("capacity", capacity)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Output a fact about factorials.
+@inlinable @inline(__always)
+public static func fact(
+) -> StringTensor {
+  let op = TFE_Op("Fact")
+  
+  return op.execute(Int(1))
+}
+
+///   This op is used as a placeholder in If branch functions. It doesn't provide a
+///   valid output when run, so must either be removed (e.g. replaced with a
+///   function input) or guaranteed not to be used (e.g. if mirroring an
+///   intermediate output needed for the gradient computation of the other branch).
+///
+/// - Attrs:
+///   - dtype: The type of the output.
+///   - shape:     The purported shape of the output. This is only used for shape inference;
+///         the output will not necessarily have this shape. Can be a partial shape.
+///
+/// - Output output:     \"Fake\" output value. This should not be consumed by another op.
+@inlinable @inline(__always)
+public static func fakeParam<Dtype: TensorFlowScalar>(
+  shape: TensorShape?
+) -> Tensor<Dtype> {
+  let op = TFE_Op("FakeParam")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape", shape)
+  return op.execute(Int(1))
+}
+
+/// Fake-quantize the 'inputs' tensor, type float to 'outputs' tensor of same type.
+///
+/// Attributes `[min; max]` define the clamping range for the `inputs` data.
+/// `inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
+/// when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
+/// then de-quantized and output as floats in `[min; max]` interval.
+/// `num_bits` is the bitwidth of the quantization; between 2 and 16, inclusive.
+///
+/// Before quantization, `min` and `max` values are adjusted with the following
+/// logic.
+/// It is suggested to have `min <= 0 <= max`. If `0` is not in the range of values,
+/// the behavior can be unexpected:
+/// If `0 < min < max`: `min_adj = 0` and `max_adj = max - min`.
+/// If `min < max < 0`: `min_adj = min - max` and `max_adj = 0`.
+/// If `min <= 0 <= max`: `scale = (max - min) / (2^num_bits - 1) `,
+/// `min_adj = scale * round(min / scale)` and `max_adj = max + min_adj - min`.
+///
+/// Quantization is called fake since the output is still in floating point.
+@inlinable @inline(__always)
+public static func fakeQuantWithMinMaxArgs(
+  inputs: Tensor<Float>,
+  min: Double = -6,
+  max: Double = 6,
+  numBits: Int64 = 8,
+  narrowRange: Bool = false
+) -> Tensor<Float> {
+  let op = TFE_Op("FakeQuantWithMinMaxArgs")
+  op.setAttr("min", min)
+  op.setAttr("max", max)
+  op.setAttr("num_bits", numBits)
+  op.setAttr("narrow_range", narrowRange)
+  let _ = op.addInput(inputs)
+  return op.execute(Int(1))
+}
+
+/// Compute gradients for a FakeQuantWithMinMaxArgs operation.
+///
+/// - Parameters:
+///   - gradients: Backpropagated gradients above the FakeQuantWithMinMaxArgs operation.
+///   - inputs: Values passed as inputs to the FakeQuantWithMinMaxArgs operation.
+///
+/// - Output backprops: Backpropagated gradients below the FakeQuantWithMinMaxArgs operation:
+///   `gradients * (inputs >= min && inputs <= max)`.
+@inlinable @inline(__always)
+public static func fakeQuantWithMinMaxArgsGradient(
+  gradients: Tensor<Float>,
+  inputs: Tensor<Float>,
+  min: Double = -6,
+  max: Double = 6,
+  numBits: Int64 = 8,
+  narrowRange: Bool = false
+) -> Tensor<Float> {
+  let op = TFE_Op("FakeQuantWithMinMaxArgsGradient")
+  op.setAttr("min", min)
+  op.setAttr("max", max)
+  op.setAttr("num_bits", numBits)
+  op.setAttr("narrow_range", narrowRange)
+  let _ = op.addInput(gradients)
+  let _ = op.addInput(inputs)
+  return op.execute(Int(1))
+}
+
+/// Fake-quantize the 'inputs' tensor of type float via global float scalars `min`
+///
+/// and `max` to 'outputs' tensor of same shape as `inputs`.
+///
+/// `[min; max]` define the clamping range for the `inputs` data.
+/// `inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
+/// when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
+/// then de-quantized and output as floats in `[min; max]` interval.
+/// `num_bits` is the bitwidth of the quantization; between 2 and 16, inclusive.
+///
+/// Before quantization, `min` and `max` values are adjusted with the following
+/// logic.
+/// It is suggested to have `min <= 0 <= max`. If `0` is not in the range of values,
+/// the behavior can be unexpected:
+/// If `0 < min < max`: `min_adj = 0` and `max_adj = max - min`.
+/// If `min < max < 0`: `min_adj = min - max` and `max_adj = 0`.
+/// If `min <= 0 <= max`: `scale = (max - min) / (2^num_bits - 1) `,
+/// `min_adj = scale * round(min / scale)` and `max_adj = max + min_adj - min`.
+///
+/// This operation has a gradient and thus allows for training `min` and `max`
+/// values.
+@inlinable @inline(__always)
+public static func fakeQuantWithMinMaxVars(
+  inputs: Tensor<Float>,
+  min: Tensor<Float>,
+  max: Tensor<Float>,
+  numBits: Int64 = 8,
+  narrowRange: Bool = false
+) -> Tensor<Float> {
+  let op = TFE_Op("FakeQuantWithMinMaxVars")
+  op.setAttr("num_bits", numBits)
+  op.setAttr("narrow_range", narrowRange)
+  let _ = op.addInput(inputs)
+  let _ = op.addInput(min)
+  let _ = op.addInput(max)
+  return op.execute(Int(1))
+}
+
+/// Compute gradients for a FakeQuantWithMinMaxVars operation.
+///
+/// - Parameters:
+///   - gradients: Backpropagated gradients above the FakeQuantWithMinMaxVars operation.
+///   - inputs: Values passed as inputs to the FakeQuantWithMinMaxVars operation.
+///     min, max: Quantization interval, scalar floats.
+///
+/// - Attrs:
+///   - num_bits: The bitwidth of the quantization; between 2 and 8, inclusive.
+///   - narrow_range: Whether to quantize into 2^num_bits - 1 distinct values.
+///
+/// - Outputs:
+///   - backprops_wrt_input: Backpropagated gradients w.r.t. inputs:
+///     `gradients * (inputs >= min && inputs <= max)`.
+///   - backprop_wrt_min: Backpropagated gradients w.r.t. min parameter:
+///     `sum(gradients * (inputs < min))`.
+///   - backprop_wrt_max: Backpropagated gradients w.r.t. max parameter:
+///     `sum(gradients * (inputs > max))`.
+@inlinable @inline(__always)
+public static func fakeQuantWithMinMaxVarsGradient(
+  gradients: Tensor<Float>,
+  inputs: Tensor<Float>,
+  min: Tensor<Float>,
+  max: Tensor<Float>,
+  numBits: Int64 = 8,
+  narrowRange: Bool = false
+) -> (backpropsWrtInput: Tensor<Float>, backpropWrtMin: Tensor<Float>, backpropWrtMax: Tensor<Float>) {
+  let op = TFE_Op("FakeQuantWithMinMaxVarsGradient")
+  op.setAttr("num_bits", numBits)
+  op.setAttr("narrow_range", narrowRange)
+  let _ = op.addInput(gradients)
+  let _ = op.addInput(inputs)
+  let _ = op.addInput(min)
+  let _ = op.addInput(max)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Fake-quantize the 'inputs' tensor of type float and one of the shapes: `[d]`,
+///
+/// `[b, d]` `[b, h, w, d]` via per-channel floats `min` and `max` of shape `[d]`
+/// to 'outputs' tensor of same shape as `inputs`.
+///
+/// `[min; max]` define the clamping range for the `inputs` data.
+/// `inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
+/// when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
+/// then de-quantized and output as floats in `[min; max]` interval.
+/// `num_bits` is the bitwidth of the quantization; between 2 and 16, inclusive.
+///
+/// Before quantization, `min` and `max` values are adjusted with the following
+/// logic.
+/// It is suggested to have `min <= 0 <= max`. If `0` is not in the range of values,
+/// the behavior can be unexpected:
+/// If `0 < min < max`: `min_adj = 0` and `max_adj = max - min`.
+/// If `min < max < 0`: `min_adj = min - max` and `max_adj = 0`.
+/// If `min <= 0 <= max`: `scale = (max - min) / (2^num_bits - 1) `,
+/// `min_adj = scale * round(min / scale)` and `max_adj = max + min_adj - min`.
+///
+/// This operation has a gradient and thus allows for training `min` and `max`
+/// values.
+@inlinable @inline(__always)
+public static func fakeQuantWithMinMaxVarsPerChannel(
+  inputs: Tensor<Float>,
+  min: Tensor<Float>,
+  max: Tensor<Float>,
+  numBits: Int64 = 8,
+  narrowRange: Bool = false
+) -> Tensor<Float> {
+  let op = TFE_Op("FakeQuantWithMinMaxVarsPerChannel")
+  op.setAttr("num_bits", numBits)
+  op.setAttr("narrow_range", narrowRange)
+  let _ = op.addInput(inputs)
+  let _ = op.addInput(min)
+  let _ = op.addInput(max)
+  return op.execute(Int(1))
+}
+
+/// Compute gradients for a FakeQuantWithMinMaxVarsPerChannel operation.
+///
+/// - Parameters:
+///   - gradients: Backpropagated gradients above the FakeQuantWithMinMaxVars operation,
+///     shape one of: `[d]`, `[b, d]`,  `[b, h, w, d]`.
+///   - inputs: Values passed as inputs to the FakeQuantWithMinMaxVars operation, shape
+///       same as `gradients`.
+///     min, max: Quantization interval, floats of shape `[d]`.
+///
+/// - Attrs:
+///   - num_bits: The bitwidth of the quantization; between 2 and 16, inclusive.
+///   - narrow_range: Whether to quantize into 2^num_bits - 1 distinct values.
+///
+/// - Outputs:
+///   - backprops_wrt_input: Backpropagated gradients w.r.t. inputs, shape same as
+///     `inputs`:
+///       `gradients * (inputs >= min && inputs <= max)`.
+///   - backprop_wrt_min: Backpropagated gradients w.r.t. min parameter, shape `[d]`:
+///     `sum_per_d(gradients * (inputs < min))`.
+///   - backprop_wrt_max: Backpropagated gradients w.r.t. max parameter, shape `[d]`:
+///     `sum_per_d(gradients * (inputs > max))`.
+@inlinable @inline(__always)
+public static func fakeQuantWithMinMaxVarsPerChannelGradient(
+  gradients: Tensor<Float>,
+  inputs: Tensor<Float>,
+  min: Tensor<Float>,
+  max: Tensor<Float>,
+  numBits: Int64 = 8,
+  narrowRange: Bool = false
+) -> (backpropsWrtInput: Tensor<Float>, backpropWrtMin: Tensor<Float>, backpropWrtMax: Tensor<Float>) {
+  let op = TFE_Op("FakeQuantWithMinMaxVarsPerChannelGradient")
+  op.setAttr("num_bits", numBits)
+  op.setAttr("narrow_range", narrowRange)
+  let _ = op.addInput(gradients)
+  let _ = op.addInput(inputs)
+  let _ = op.addInput(min)
+  let _ = op.addInput(max)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Creates a tensor filled with a scalar value.
+///
+/// This operation creates a tensor of shape `dims` and fills it with `value`.
+///
+/// For example:
+///
+/// ```
+/// # Output tensor has shape [2, 3].
+/// fill([2, 3], 9) ==> [[9, 9, 9]
+///                      [9, 9, 9]]
+/// ```
+///
+/// `tf.fill` differs from `tf.constant` in a few ways:
+///
+/// *   `tf.fill` only supports scalar contents, whereas `tf.constant` supports
+///     Tensor values.
+/// *   `tf.fill` creates an Op in the computation graph that constructs the actual
+///     Tensor value at runtime. This is in contrast to `tf.constant` which embeds
+///     the entire Tensor into the graph with a `Const` node.
+/// *   Because `tf.fill` evaluates at graph runtime, it supports dynamic shapes
+///     based on other runtime Tensors, unlike `tf.constant`.
+///
+/// - Parameters:
+///   - dims: 1-D. Represents the shape of the output tensor.
+///   - value: 0-D (scalar). Value to fill the returned tensor.
+///
+///     @compatibility(numpy)
+///     Equivalent to np.full
+///     @end_compatibility
+@inlinable @inline(__always)
+public static func fill<
+    T: TensorFlowScalar,
+    IndexType: BinaryInteger & TensorFlowScalar
+>(
+  dims: Tensor<IndexType>,
+  value: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Fill")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("index_type", IndexType.tensorFlowDataType)
+  let _ = op.addInput(dims)
+  let _ = op.addInput(value)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset containing elements of first component of `input_dataset` having true in the last component.
+@inlinable @inline(__always)
+public static func filterByLastComponentDataset(
+  inputDataset: VariantHandle,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("FilterByLastComponentDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset containing elements of `input_dataset` matching `predicate`.
+///
+/// The `predicate` function must return a scalar boolean and accept the
+/// following arguments:
+///
+/// * One tensor for each component of an element of `input_dataset`.
+/// * One tensor for each value in `other_arguments`.
+///
+/// - Parameter other_arguments: A list of tensors, typically values that were captured when
+///   building a closure for `predicate`.
+///
+/// - Attr predicate: A function returning a scalar boolean.
+@inlinable @inline(__always)
+public static func filterDataset<
+    PredicateIn: TensorGroup,
+    PredicateOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  otherArguments: Targuments,
+  predicate: (PredicateIn) -> PredicateOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("FilterDataset")
+  op.setAttr("predicate", predicate)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(otherArguments)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func fiveFloatOutputs(
+) -> (a: Tensor<Float>, b: Tensor<Float>, c: Tensor<Float>, d: Tensor<Float>, e: Tensor<Float>) {
+  let op = TFE_Op("FiveFloatOutputs")
+  
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Creates a dataset that emits the records from one or more binary files.
+///
+/// - Parameters:
+///   - filenames: A scalar or a vector containing the name(s) of the file(s) to be
+///     read.
+///   - header_bytes: A scalar representing the number of bytes to skip at the
+///     beginning of a file.
+///   - record_bytes: A scalar representing the number of bytes in each record.
+///   - footer_bytes: A scalar representing the number of bytes to skip at the end
+///     of a file.
+///   - buffer_size: A scalar representing the number of bytes to buffer. Must be > 0.
+@inlinable @inline(__always)
+public static func fixedLengthRecordDataset(
+  filenames: StringTensor,
+  headerBytes: Tensor<Int64>,
+  recordBytes: Tensor<Int64>,
+  footerBytes: Tensor<Int64>,
+  bufferSize: Tensor<Int64>
+) -> VariantHandle {
+  let op = TFE_Op("FixedLengthRecordDataset")
+  let _ = op.addInput(filenames)
+  let _ = op.addInput(headerBytes)
+  let _ = op.addInput(recordBytes)
+  let _ = op.addInput(footerBytes)
+  let _ = op.addInput(bufferSize)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func fixedLengthRecordDatasetV2(
+  filenames: StringTensor,
+  headerBytes: Tensor<Int64>,
+  recordBytes: Tensor<Int64>,
+  footerBytes: Tensor<Int64>,
+  bufferSize: Tensor<Int64>,
+  compressionType: StringTensor
+) -> VariantHandle {
+  let op = TFE_Op("FixedLengthRecordDatasetV2")
+  let _ = op.addInput(filenames)
+  let _ = op.addInput(headerBytes)
+  let _ = op.addInput(recordBytes)
+  let _ = op.addInput(footerBytes)
+  let _ = op.addInput(bufferSize)
+  let _ = op.addInput(compressionType)
+  return op.execute(Int(1))
+}
+
+/// A Reader that outputs fixed-length records from a file.
+///
+/// - Attrs:
+///   - header_bytes: Number of bytes in the header, defaults to 0.
+///   - record_bytes: Number of bytes in the record.
+///   - footer_bytes: Number of bytes in the footer, defaults to 0.
+///   - hop_bytes: Number of bytes to hop before each read. Default of 0 means using
+///     record_bytes.
+///   - container: If non-empty, this reader is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this reader is named in the given bucket
+///     with this shared_name. Otherwise, the node name is used instead.
+///   - encoding: The type of encoding for the file. Currently ZLIB and GZIP
+///     are supported. Defaults to none.
+///
+/// - Output reader_handle: The handle to reference the Reader.
+@inlinable @inline(__always)
+public static func fixedLengthRecordReaderV2(
+  headerBytes: Int64 = 0,
+  recordBytes: Int64,
+  footerBytes: Int64 = 0,
+  hopBytes: Int64 = 0,
+  container: String,
+  sharedName: String,
+  encoding: String
+) -> ResourceHandle {
+  let op = TFE_Op("FixedLengthRecordReaderV2")
+  op.setAttr("header_bytes", headerBytes)
+  op.setAttr("record_bytes", recordBytes)
+  op.setAttr("footer_bytes", footerBytes)
+  op.setAttr("hop_bytes", hopBytes)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("encoding", encoding)
+  return op.execute(Int(1))
+}
+
+/// Generates labels for candidate sampling with a learned unigram distribution.
+///
+/// A unigram sampler could use a fixed unigram distribution read from a
+/// file or passed in as an in-memory array instead of building up the distribution
+/// from data on the fly. There is also an option to skew the distribution by
+/// applying a distortion power to the weights.
+///
+/// The vocabulary file should be in CSV-like format, with the last field
+/// being the weight associated with the word.
+///
+/// For each batch, this op picks a single set of sampled candidate labels.
+///
+/// The advantages of sampling candidates per-batch are simplicity and the
+/// possibility of efficient dense matrix multiplication. The disadvantage is that
+/// the sampled candidates must be chosen independently of the context and of the
+/// true labels.
+///
+/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
+///   IDs of the num_true target_classes in the corresponding original label.
+///
+/// - Attrs:
+///   - num_true: Number of true labels per context.
+///   - num_sampled: Number of candidates to randomly sample.
+///   - unique: If unique is true, we sample with rejection, so that all sampled
+///     candidates in a batch are unique. This requires some approximation to
+///     estimate the post-rejection sampling probabilities.
+///   - range_max: The sampler will sample integers from the interval [0, range_max).
+///   - vocab_file: Each valid line in this file (which should have a CSV-like format)
+///     corresponds to a valid word ID. IDs are in sequential order, starting from
+///     num_reserved_ids. The last entry in each line is expected to be a value
+///     corresponding to the count or relative probability. Exactly one of vocab_file
+///     and unigrams needs to be passed to this op.
+///   - distortion: The distortion is used to skew the unigram probability distribution.
+///     Each weight is first raised to the distortion's power before adding to the
+///     internal unigram distribution. As a result, distortion = 1.0 gives regular
+///     unigram sampling (as defined by the vocab file), and distortion = 0.0 gives
+///     a uniform distribution.
+///   - num_reserved_ids: Optionally some reserved IDs can be added in the range [0,
+///     ..., num_reserved_ids) by the users. One use case is that a special unknown
+///     word token is used as ID 0. These IDs will have a sampling probability of 0.
+///   - num_shards: A sampler can be used to sample from a subset of the original range
+///     in order to speed up the whole computation through parallelism. This parameter
+///     (together with 'shard') indicates the number of partitions that are being
+///     used in the overall computation.
+///   - shard: A sampler can be used to sample from a subset of the original range
+///     in order to speed up the whole computation through parallelism. This parameter
+///     (together with 'num_shards') indicates the particular partition number of a
+///     sampler op, when partitioning is being used.
+///   - unigrams: A list of unigram counts or probabilities, one per ID in sequential
+///     order. Exactly one of vocab_file and unigrams should be passed to this op.
+///   - seed: If either seed or seed2 are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///   - sampled_candidates: A vector of length num_sampled, in which each element is
+///     the ID of a sampled candidate.
+///   - true_expected_count: A batch_size * num_true matrix, representing
+///     the number of times each candidate is expected to occur in a batch
+///     of sampled candidates. If unique=true, then this is a probability.
+///   - sampled_expected_count: A vector of length num_sampled, for each sampled
+///     candidate representing the number of times the candidate is expected
+///     to occur in a batch of sampled candidates.  If unique=true, then this is a
+///     probability.
+@inlinable @inline(__always)
+public static func fixedUnigramCandidateSampler(
+  trueClasses: Tensor<Int64>,
+  numTrue: Int64,
+  numSampled: Int64,
+  unique: Bool,
+  rangeMax: Int64,
+  vocabFile: String,
+  distortion: Double = 1,
+  numReservedIds: Int64 = 0,
+  numShards: Int64 = 1,
+  shard: Int64 = 0,
+  unigrams: [Double],
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
+  let op = TFE_Op("FixedUnigramCandidateSampler")
+  op.setAttr("num_true", numTrue)
+  op.setAttr("num_sampled", numSampled)
+  op.setAttr("unique", unique)
+  op.setAttr("range_max", rangeMax)
+  op.setAttr("vocab_file", vocabFile)
+  op.setAttr("distortion", distortion)
+  op.setAttr("num_reserved_ids", numReservedIds)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard", shard)
+  op.setAttr("unigrams", unigrams)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(trueClasses)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+///
+/// Unlike MapDataset, the `f` in FlatMapDataset is expected to return a
+/// Dataset variant, and FlatMapDataset will flatten successive results
+/// into a single Dataset.
+///
+/// - Attr f: A function mapping elements of `input_dataset`, concatenated with
+///   `other_arguments`, to a Dataset variant that contains elements matching
+///   `output_types` and `output_shapes`.
+@inlinable @inline(__always)
+public static func flatMapDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  otherArguments: Targuments,
+  f: (FIn) -> FOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("FlatMapDataset")
+  op.setAttr("f", f)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(otherArguments)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func floatInput(
+  _ a: Tensor<Float>
+) {
+  let op = TFE_Op("FloatInput")
+  let _ = op.addInput(a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func floatOutput(
+) -> Tensor<Float> {
+  let op = TFE_Op("FloatOutput")
+  
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func floatOutputStringOutput(
+) -> (a: Tensor<Float>, b: StringTensor) {
+  let op = TFE_Op("FloatOutputStringOutput")
+  
+  return op.execute(Int(1), Int(1))
+}
+
+/// Returns element-wise largest integer not greater than x.
+@inlinable @inline(__always)
+public static func floor<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Floor")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns x // y element-wise.
+///
+/// *NOTE*: `FloorDiv` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func floorDiv<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("FloorDiv")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns element-wise remainder of division. When `x < 0` xor `y < 0` is
+///
+/// true, this follows Python semantics in that the result here is consistent
+/// with a flooring divide. E.g. `floor(x / y) * y + mod(x, y) = x`.
+///
+/// *NOTE*: `FloorMod` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func floorMod<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("FloorMod")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func flushSummaryWriter(
+  writer: ResourceHandle
+) {
+  let op = TFE_Op("FlushSummaryWriter")
+  let _ = op.addInput(writer)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func foo1(
+  _ a: Tensor<Float>,
+  _ b: Tensor<Int32>,
+  c: Tensor<Int32>
+) -> (d: Tensor<Float>, e: Tensor<Int32>) {
+  let op = TFE_Op("Foo1")
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  let _ = op.addInput(c)
+  return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func foo2(
+  _ a: Tensor<Float>,
+  _ b: StringTensor,
+  c: StringTensor
+) -> (d: Tensor<Float>, e: Tensor<Int32>) {
+  let op = TFE_Op("Foo2")
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  let _ = op.addInput(c)
+  return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func foo3(
+  _ a: Tensor<Float>,
+  _ b: StringTensor,
+  c: Tensor<Float>
+) -> (d: Tensor<Float>, e: Tensor<Int32>) {
+  let op = TFE_Op("Foo3")
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  let _ = op.addInput(c)
+  return op.execute(Int(1), Int(1))
+}
+
+///   ```python
+///    output = input;
+///    for i in range(start, limit, delta)
+///      output = body(i, output);
+///   ```
+///
+/// - Parameters:
+///   - start: The lower bound. An int32
+///   - limit: The upper bound. An int32
+///   - delta: The increment. An int32
+///   - input: A list of input tensors whose types are T.
+///
+/// - Attrs:
+///   - T: A list of dtypes.
+///   - body:     A function that takes a list of tensors (int32, T) and returns another
+///         list of tensors (T).
+///
+/// - Output output: A list of output tensors whose types are T.
+@inlinable @inline(__always)
+public static func for_<
+    T: TensorArrayProtocol,
+    BodyIn: TensorGroup,
+    BodyOut: TensorGroup
+>(
+  start: Tensor<Int32>,
+  limit: Tensor<Int32>,
+  delta: Tensor<Int32>,
+  _ input: T,
+  body: (BodyIn) -> BodyOut
+) -> T {
+  let op = TFE_Op("For")
+  op.setAttr("T", input._typeList)
+  op.setAttr("body", body)
+  let _ = op.addInput(start)
+  let _ = op.addInput(limit)
+  let _ = op.addInput(delta)
+  let _ = op.addInputList(input)
+  return op.execute(Int(input._typeList.count))
+}
+
+/// Performs fractional average pooling on the input.
+///
+/// Fractional average pooling is similar to Fractional max pooling in the pooling
+/// region generation step. The only difference is that after pooling regions are
+/// generated, a mean operation is performed instead of a max operation in each
+/// pooling region.
+///
+/// - Parameter value: 4-D with shape `[batch, height, width, channels]`.
+///
+/// - Attrs:
+///   - pooling_ratio: Pooling ratio for each dimension of `value`, currently only
+///     supports row and col dimension and should be >= 1.0. For example, a valid
+///     pooling ratio looks like [1.0, 1.44, 1.73, 1.0]. The first and last elements
+///     must be 1.0 because we don't allow pooling on batch and channels
+///     dimensions. 1.44 and 1.73 are pooling ratio on height and width dimensions
+///     respectively.
+///   - pseudo_random: When set to True, generates the pooling sequence in a
+///     pseudorandom fashion, otherwise, in a random fashion. Check paper [Benjamin
+///     Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071) for
+///     difference between pseudorandom and random.
+///   - overlapping: When set to True, it means when pooling, the values at the boundary
+///     of adjacent pooling cells are used by both cells. For example:
+///
+///     `index  0  1  2  3  4`
+///
+///     `value  20 5  16 3  7`
+///
+///     If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
+///     The result would be [41/3, 26/3] for fractional avg pooling.
+///   - deterministic: When set to True, a fixed pooling region will be used when
+///     iterating over a FractionalAvgPool node in the computation graph. Mainly used
+///     in unit test to make FractionalAvgPool deterministic.
+///   - seed: If either seed or seed2 are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///   - output: output tensor after fractional avg pooling.
+///   - row_pooling_sequence: row pooling sequence, needed to calculate gradient.
+///   - col_pooling_sequence: column pooling sequence, needed to calculate gradient.
+@inlinable @inline(__always)
+public static func fractionalAvgPool<T: Numeric & TensorFlowScalar>(
+  value: Tensor<T>,
+  poolingRatio: [Double],
+  pseudoRandom: Bool = false,
+  overlapping: Bool = false,
+  deterministic: Bool = false,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> (output: Tensor<T>, rowPoolingSequence: Tensor<Int64>, colPoolingSequence: Tensor<Int64>) {
+  let op = TFE_Op("FractionalAvgPool")
+  op.setAttr("pooling_ratio", poolingRatio)
+  op.setAttr("pseudo_random", pseudoRandom)
+  op.setAttr("overlapping", overlapping)
+  op.setAttr("deterministic", deterministic)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(value)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes gradient of the FractionalAvgPool function.
+///
+/// Unlike FractionalMaxPoolGrad, we don't need to find arg_max for
+/// FractionalAvgPoolGrad, we just need to evenly back-propagate each element of
+/// out_backprop to those indices that form the same pooling cell. Therefore, we
+/// just need to know the shape of original input tensor, instead of the whole
+/// tensor.
+///
+/// - Parameters:
+///   - orig_input_tensor_shape: Original input tensor shape for `fractional_avg_pool`
+///   - out_backprop: 4-D with shape `[batch, height, width, channels]`.  Gradients
+///     w.r.t. the output of `fractional_avg_pool`.
+///   - row_pooling_sequence: row pooling sequence, form pooling region with
+///     col_pooling_sequence.
+///   - col_pooling_sequence: column pooling sequence, form pooling region with
+///     row_pooling sequence.
+///
+/// - Attr overlapping: When set to True, it means when pooling, the values at the boundary
+///   of adjacent pooling cells are used by both cells. For example:
+///
+///   `index  0  1  2  3  4`
+///
+///   `value  20 5  16 3  7`
+///
+///   If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
+///   The result would be [41/3, 26/3] for fractional avg pooling.
+///
+/// - Output output: 4-D.  Gradients w.r.t. the input of `fractional_avg_pool`.
+@inlinable @inline(__always)
+public static func fractionalAvgPoolGrad<T: Numeric & TensorFlowScalar>(
+  origInputTensorShape: Tensor<Int64>,
+  outBackprop: Tensor<T>,
+  rowPoolingSequence: Tensor<Int64>,
+  colPoolingSequence: Tensor<Int64>,
+  overlapping: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("FractionalAvgPoolGrad")
+  op.setAttr("overlapping", overlapping)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(origInputTensorShape)
+  let _ = op.addInput(outBackprop)
+  let _ = op.addInput(rowPoolingSequence)
+  let _ = op.addInput(colPoolingSequence)
+  return op.execute(Int(1))
+}
+
+/// Performs fractional max pooling on the input.
+///
+/// Fractional max pooling is slightly different than regular max pooling.  In
+/// regular max pooling, you downsize an input set by taking the maximum value of
+/// smaller N x N subsections of the set (often 2x2), and try to reduce the set by
+/// a factor of N, where N is an integer.  Fractional max pooling, as you might
+/// expect from the word "fractional", means that the overall reduction ratio N
+/// does not have to be an integer.
+///
+/// The sizes of the pooling regions are generated randomly but are fairly uniform.
+/// For example, let's look at the height dimension, and the constraints on the
+/// list of rows that will be pool boundaries.
+///
+/// First we define the following:
+///
+/// 1.  input_row_length : the number of rows from the input set
+/// 2.  output_row_length : which will be smaller than the input
+/// 3.  alpha = input_row_length / output_row_length : our reduction ratio
+/// 4.  K = floor(alpha)
+/// 5.  row_pooling_sequence : this is the result list of pool boundary rows
+///
+/// Then, row_pooling_sequence should satisfy:
+///
+/// 1.  a[0] = 0 : the first value of the sequence is 0
+/// 2.  a[end] = input_row_length : the last value of the sequence is the size
+/// 3.  K <= (a[i+1] - a[i]) <= K+1 : all intervals are K or K+1 size
+/// 4.  length(row_pooling_sequence) = output_row_length+1
+///
+/// For more details on fractional max pooling, see this paper:
+/// [Benjamin Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071)
+///
+/// - Parameter value: 4-D with shape `[batch, height, width, channels]`.
+///
+/// - Attrs:
+///   - pooling_ratio: Pooling ratio for each dimension of `value`, currently only
+///     supports row and col dimension and should be >= 1.0. For example, a valid
+///     pooling ratio looks like [1.0, 1.44, 1.73, 1.0]. The first and last elements
+///     must be 1.0 because we don't allow pooling on batch and channels
+///     dimensions. 1.44 and 1.73 are pooling ratio on height and width dimensions
+///     respectively.
+///   - pseudo_random: When set to True, generates the pooling sequence in a
+///     pseudorandom fashion, otherwise, in a random fashion. Check paper [Benjamin
+///     Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071) for
+///     difference between pseudorandom and random.
+///   - overlapping: When set to True, it means when pooling, the values at the boundary
+///     of adjacent pooling cells are used by both cells. For example:
+///
+///     `index  0  1  2  3  4`
+///
+///     `value  20 5  16 3  7`
+///
+///     If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
+///     The result would be [20, 16] for fractional max pooling.
+///   - deterministic: When set to True, a fixed pooling region will be used when
+///     iterating over a FractionalMaxPool node in the computation graph. Mainly used
+///     in unit test to make FractionalMaxPool deterministic.
+///   - seed: If either seed or seed2 are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///   - output: output tensor after fractional max pooling.
+///   - row_pooling_sequence: row pooling sequence, needed to calculate gradient.
+///   - col_pooling_sequence: column pooling sequence, needed to calculate gradient.
+@inlinable @inline(__always)
+public static func fractionalMaxPool<T: Numeric & TensorFlowScalar>(
+  value: Tensor<T>,
+  poolingRatio: [Double],
+  pseudoRandom: Bool = false,
+  overlapping: Bool = false,
+  deterministic: Bool = false,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> (output: Tensor<T>, rowPoolingSequence: Tensor<Int64>, colPoolingSequence: Tensor<Int64>) {
+  let op = TFE_Op("FractionalMaxPool")
+  op.setAttr("pooling_ratio", poolingRatio)
+  op.setAttr("pseudo_random", pseudoRandom)
+  op.setAttr("overlapping", overlapping)
+  op.setAttr("deterministic", deterministic)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(value)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes gradient of the FractionalMaxPool function.
+///
+/// - Parameters:
+///   - orig_input: Original input for `fractional_max_pool`
+///   - orig_output: Original output for `fractional_max_pool`
+///   - out_backprop: 4-D with shape `[batch, height, width, channels]`.  Gradients
+///     w.r.t. the output of `fractional_max_pool`.
+///   - row_pooling_sequence: row pooling sequence, form pooling region with
+///     col_pooling_sequence.
+///   - col_pooling_sequence: column pooling sequence, form pooling region with
+///     row_pooling sequence.
+///
+/// - Attr overlapping: When set to True, it means when pooling, the values at the boundary
+///   of adjacent pooling cells are used by both cells. For example:
+///
+///   `index  0  1  2  3  4`
+///
+///   `value  20 5  16 3  7`
+///
+///   If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
+///   The result would be [20, 16] for fractional max pooling.
+///
+/// - Output output: 4-D.  Gradients w.r.t. the input of `fractional_max_pool`.
+@inlinable @inline(__always)
+public static func fractionalMaxPoolGrad<T: Numeric & TensorFlowScalar>(
+  origInput: Tensor<T>,
+  origOutput: Tensor<T>,
+  outBackprop: Tensor<T>,
+  rowPoolingSequence: Tensor<Int64>,
+  colPoolingSequence: Tensor<Int64>,
+  overlapping: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("FractionalMaxPoolGrad")
+  op.setAttr("overlapping", overlapping)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(origInput)
+  let _ = op.addInput(origOutput)
+  let _ = op.addInput(outBackprop)
+  let _ = op.addInput(rowPoolingSequence)
+  let _ = op.addInput(colPoolingSequence)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func funcAttr<FIn: TensorGroup,
+    FOut: TensorGroup>(
+  f: (FIn) -> FOut
+) {
+  let op = TFE_Op("FuncAttr")
+  op.setAttr("f", f)
+  op.execute()
+}
+
+/// Batch normalization.
+///
+/// Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
+/// The size of 1D Tensors matches the dimension C of the 4D Tensors.
+///
+/// - Parameters:
+///   - x: A 4D Tensor for input data.
+///   - scale: A 1D Tensor for scaling factor, to scale the normalized x.
+///   - offset: A 1D Tensor for offset, to shift to the normalized x.
+///   - mean: A 1D Tensor for population mean. Used for inference only;
+///     must be empty for training.
+///   - variance: A 1D Tensor for population variance. Used for inference only;
+///     must be empty for training.
+///
+/// - Attrs:
+///   - T: The data type for the elements of input and output Tensors.
+///   - epsilon: A small float number added to the variance of x.
+///   - data_format: The data format for x and y. Either "NHWC" (default) or "NCHW".
+///   - is_training: A bool value to indicate the operation is for training (default)
+///     or inference.
+///
+/// - Outputs:
+///   - y: A 4D Tensor for output data.
+///   - batch_mean: A 1D Tensor for the computed batch mean, to be used by TensorFlow
+///     to compute the running mean.
+///   - batch_variance: A 1D Tensor for the computed batch variance, to be used by
+///     TensorFlow to compute the running variance.
+///   - reserve_space_1: A 1D Tensor for the computed batch mean, to be reused
+///     in the gradient computation.
+///   - reserve_space_2: A 1D Tensor for the computed batch variance (inverted variance
+///     in the cuDNN case), to be reused in the gradient computation.
+@inlinable @inline(__always)
+public static func fusedBatchNorm<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  scale: Tensor<T>,
+  offset: Tensor<T>,
+  mean: Tensor<T>,
+  variance: Tensor<T>,
+  epsilon: Double = 0.0001,
+  dataFormat: DataFormat = .nhwc,
+  isTraining: Bool = true
+) -> (y: Tensor<T>, batchMean: Tensor<T>, batchVariance: Tensor<T>, reserveSpace1: Tensor<T>, reserveSpace2: Tensor<T>) {
+  let op = TFE_Op("FusedBatchNorm")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("epsilon", epsilon)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("is_training", isTraining)
+  let _ = op.addInput(x)
+  let _ = op.addInput(scale)
+  let _ = op.addInput(offset)
+  let _ = op.addInput(mean)
+  let _ = op.addInput(variance)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Gradient for batch normalization.
+///
+/// Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
+/// The size of 1D Tensors matches the dimension C of the 4D Tensors.
+///
+/// - Parameters:
+///   - y_backprop: A 4D Tensor for the gradient with respect to y.
+///   - x: A 4D Tensor for input data.
+///   - scale: A 1D Tensor for scaling factor, to scale the normalized x.
+///   - reserve_space_1: When is_training is True, a 1D Tensor for the computed batch
+///     mean to be reused in gradient computation. When is_training is
+///     False, a 1D Tensor for the population mean to be reused in both
+///     1st and 2nd order gradient computation.
+///   - reserve_space_2: When is_training is True, a 1D Tensor for the computed batch
+///     variance (inverted variance in the cuDNN case) to be reused in
+///     gradient computation. When is_training is False, a 1D Tensor
+///     for the population variance to be reused in both 1st and 2nd
+///     order gradient computation.
+///
+/// - Attrs:
+///   - T: The data type for the elements of input and output Tensors.
+///   - epsilon: A small float number added to the variance of x.
+///   - data_format: The data format for y_backprop, x, x_backprop.
+///     Either "NHWC" (default) or "NCHW".
+///   - is_training: A bool value to indicate the operation is for training (default)
+///     or inference.
+///
+/// - Outputs:
+///   - x_backprop: A 4D Tensor for the gradient with respect to x.
+///   - scale_backprop: A 1D Tensor for the gradient with respect to scale.
+///   - offset_backprop: A 1D Tensor for the gradient with respect to offset.
+///   - reserve_space_3: Unused placeholder to match the mean input in FusedBatchNorm.
+///   - reserve_space_4: Unused placeholder to match the variance input
+///     in FusedBatchNorm.
+@inlinable @inline(__always)
+public static func fusedBatchNormGrad<T: FloatingPoint & TensorFlowScalar>(
+  yBackprop: Tensor<T>,
+  _ x: Tensor<T>,
+  scale: Tensor<T>,
+  reserveSpace1: Tensor<T>,
+  reserveSpace2: Tensor<T>,
+  epsilon: Double = 0.0001,
+  dataFormat: DataFormat = .nhwc,
+  isTraining: Bool = true
+) -> (xBackprop: Tensor<T>, scaleBackprop: Tensor<T>, offsetBackprop: Tensor<T>, reserveSpace3: Tensor<T>, reserveSpace4: Tensor<T>) {
+  let op = TFE_Op("FusedBatchNormGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("epsilon", epsilon)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("is_training", isTraining)
+  let _ = op.addInput(yBackprop)
+  let _ = op.addInput(x)
+  let _ = op.addInput(scale)
+  let _ = op.addInput(reserveSpace1)
+  let _ = op.addInput(reserveSpace2)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Gradient for batch normalization.
+///
+/// Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
+/// The size of 1D Tensors matches the dimension C of the 4D Tensors.
+///
+/// - Parameters:
+///   - y_backprop: A 4D Tensor for the gradient with respect to y.
+///   - x: A 4D Tensor for input data.
+///   - scale: A 1D Tensor for scaling factor, to scale the normalized x.
+///   - reserve_space_1: When is_training is True, a 1D Tensor for the computed batch
+///     mean to be reused in gradient computation. When is_training is
+///     False, a 1D Tensor for the population mean to be reused in both
+///     1st and 2nd order gradient computation.
+///   - reserve_space_2: When is_training is True, a 1D Tensor for the computed batch
+///     variance (inverted variance in the cuDNN case) to be reused in
+///     gradient computation. When is_training is False, a 1D Tensor
+///     for the population variance to be reused in both 1st and 2nd
+///     order gradient computation.
+///
+/// - Attrs:
+///   - T: The data type for the elements of input and output Tensors.
+///   - U: The data type for the scale, offset, mean, and variance.
+///   - epsilon: A small float number added to the variance of x.
+///   - data_format: The data format for y_backprop, x, x_backprop.
+///     Either "NHWC" (default) or "NCHW".
+///   - is_training: A bool value to indicate the operation is for training (default)
+///     or inference.
+///
+/// - Outputs:
+///   - x_backprop: A 4D Tensor for the gradient with respect to x.
+///   - scale_backprop: A 1D Tensor for the gradient with respect to scale.
+///   - offset_backprop: A 1D Tensor for the gradient with respect to offset.
+///   - reserve_space_3: Unused placeholder to match the mean input in FusedBatchNorm.
+///   - reserve_space_4: Unused placeholder to match the variance input
+///     in FusedBatchNorm.
+@inlinable @inline(__always)
+public static func fusedBatchNormGradV2<
+    T: FloatingPoint & TensorFlowScalar,
+    U: FloatingPoint & TensorFlowScalar
+>(
+  yBackprop: Tensor<T>,
+  _ x: Tensor<T>,
+  scale: Tensor<Float>,
+  reserveSpace1: Tensor<U>,
+  reserveSpace2: Tensor<U>,
+  epsilon: Double = 0.0001,
+  dataFormat: DataFormat = .nhwc,
+  isTraining: Bool = true
+) -> (xBackprop: Tensor<T>, scaleBackprop: Tensor<U>, offsetBackprop: Tensor<U>, reserveSpace3: Tensor<U>, reserveSpace4: Tensor<U>) {
+  let op = TFE_Op("FusedBatchNormGradV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("U", U.tensorFlowDataType)
+  op.setAttr("epsilon", epsilon)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("is_training", isTraining)
+  let _ = op.addInput(yBackprop)
+  let _ = op.addInput(x)
+  let _ = op.addInput(scale)
+  let _ = op.addInput(reserveSpace1)
+  let _ = op.addInput(reserveSpace2)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Batch normalization.
+///
+/// Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
+/// The size of 1D Tensors matches the dimension C of the 4D Tensors.
+///
+/// - Parameters:
+///   - x: A 4D Tensor for input data.
+///   - scale: A 1D Tensor for scaling factor, to scale the normalized x.
+///   - offset: A 1D Tensor for offset, to shift to the normalized x.
+///   - mean: A 1D Tensor for population mean. Used for inference only;
+///     must be empty for training.
+///   - variance: A 1D Tensor for population variance. Used for inference only;
+///     must be empty for training.
+///
+/// - Attrs:
+///   - T: The data type for the elements of input and output Tensors.
+///   - U: The data type for the scale, offset, mean, and variance.
+///   - epsilon: A small float number added to the variance of x.
+///   - data_format: The data format for x and y. Either "NHWC" (default) or "NCHW".
+///   - is_training: A bool value to indicate the operation is for training (default)
+///     or inference.
+///
+/// - Outputs:
+///   - y: A 4D Tensor for output data.
+///   - batch_mean: A 1D Tensor for the computed batch mean, to be used by TensorFlow
+///     to compute the running mean.
+///   - batch_variance: A 1D Tensor for the computed batch variance, to be used by
+///     TensorFlow to compute the running variance.
+///   - reserve_space_1: A 1D Tensor for the computed batch mean, to be reused
+///     in the gradient computation.
+///   - reserve_space_2: A 1D Tensor for the computed batch variance (inverted variance
+///     in the cuDNN case), to be reused in the gradient computation.
+@inlinable @inline(__always)
+public static func fusedBatchNormV2<
+    T: FloatingPoint & TensorFlowScalar,
+    U: FloatingPoint & TensorFlowScalar
+>(
+  _ x: Tensor<T>,
+  scale: Tensor<U>,
+  offset: Tensor<U>,
+  mean: Tensor<U>,
+  variance: Tensor<U>,
+  epsilon: Double = 0.0001,
+  dataFormat: DataFormat = .nhwc,
+  isTraining: Bool = true
+) -> (y: Tensor<T>, batchMean: Tensor<U>, batchVariance: Tensor<U>, reserveSpace1: Tensor<U>, reserveSpace2: Tensor<U>) {
+  let op = TFE_Op("FusedBatchNormV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("U", U.tensorFlowDataType)
+  op.setAttr("epsilon", epsilon)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("is_training", isTraining)
+  let _ = op.addInput(x)
+  let _ = op.addInput(scale)
+  let _ = op.addInput(offset)
+  let _ = op.addInput(mean)
+  let _ = op.addInput(variance)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Performs a padding as a preprocess during a convolution.
+///
+/// Similar to FusedResizeAndPadConv2d, this op allows for an optimized
+/// implementation where the spatial padding transformation stage is fused with the
+/// im2col lookup, but in this case without the bilinear filtering required for
+/// resizing. Fusing the padding prevents the need to write out the intermediate
+/// results as whole tensors, reducing memory pressure, and we can get some latency
+/// gains by merging the transformation calculations.
+/// The data_format attribute for Conv2D isn't supported by this op, and 'NHWC'
+/// order is used instead.
+/// Internally this op uses a single per-graph scratch buffer, which means that it
+/// will block if multiple versions are being run in parallel. This is because this
+/// operator is primarily an optimization to minimize memory usage.
+///
+/// - Parameters:
+///   - input: 4-D with shape `[batch, in_height, in_width, in_channels]`.
+///   - paddings: A two-column matrix specifying the padding sizes. The number of
+///     rows must be the same as the rank of `input`.
+///   - filter: 4-D with shape
+///     `[filter_height, filter_width, in_channels, out_channels]`.
+///
+/// - Attrs:
+///   - strides: 1-D of length 4.  The stride of the sliding window for each dimension
+///     of `input`. Must be in the same order as the dimension specified with format.
+///   - padding: The type of padding algorithm to use.
+@inlinable @inline(__always)
+public static func fusedPadConv2D<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  paddings: Tensor<Int32>,
+  filter: Tensor<T>,
+  mode: Mode5,
+  strides: [Int32],
+  padding: Padding
+) -> Tensor<T> {
+  let op = TFE_Op("FusedPadConv2D")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("mode", mode.cName)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(paddings)
+  let _ = op.addInput(filter)
+  return op.execute(Int(1))
+}
+
+/// Performs a resize and padding as a preprocess during a convolution.
+///
+/// It's often possible to do spatial transformations more efficiently as part of
+/// the packing stage of a convolution, so this op allows for an optimized
+/// implementation where these stages are fused together. This prevents the need to
+/// write out the intermediate results as whole tensors, reducing memory pressure,
+/// and we can get some latency gains by merging the transformation calculations.
+/// The data_format attribute for Conv2D isn't supported by this op, and defaults to
+/// 'NHWC' order.
+/// Internally this op uses a single per-graph scratch buffer, which means that it
+/// will block if multiple versions are being run in parallel. This is because this
+/// operator is primarily an optimization to minimize memory usage.
+///
+/// - Parameters:
+///   - input: 4-D with shape `[batch, in_height, in_width, in_channels]`.
+///   - size: A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+///     new size for the images.
+///   - paddings: A two-column matrix specifying the padding sizes. The number of
+///     rows must be the same as the rank of `input`.
+///   - filter: 4-D with shape
+///     `[filter_height, filter_width, in_channels, out_channels]`.
+///
+/// - Attrs:
+///   - resize_align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
+///     aligned, preserving the values at the corner pixels. Defaults to false.
+///   - strides: 1-D of length 4.  The stride of the sliding window for each dimension
+///     of `input`. Must be in the same order as the dimension specified with format.
+///   - padding: The type of padding algorithm to use.
+@inlinable @inline(__always)
+public static func fusedResizeAndPadConv2D<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  size: Tensor<Int32>,
+  paddings: Tensor<Int32>,
+  filter: Tensor<T>,
+  resizeAlignCorners: Bool = false,
+  mode: Mode5,
+  strides: [Int32],
+  padding: Padding
+) -> Tensor<T> {
+  let op = TFE_Op("FusedResizeAndPadConv2D")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("resize_align_corners", resizeAlignCorners)
+  op.setAttr("mode", mode.cName)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(size)
+  let _ = op.addInput(paddings)
+  let _ = op.addInput(filter)
+  return op.execute(Int(1))
+}
+
+/// Computes the GRU cell forward propagation for 1 time step.
+///
+/// Args
+///     x: Input to the GRU cell.
+///     h_prev: State input from the previous GRU cell.
+///     w_ru: Weight matrix for the reset and update gate.
+///     w_c: Weight matrix for the cell connection gate.
+///     b_ru: Bias vector for the reset and update gate.
+///     b_c: Bias vector for the cell connection gate.
+///
+/// Returns
+///     r: Output of the reset gate.
+///     u: Output of the update gate.
+///     c: Output of the cell connection gate.
+///     h: Current state of the GRU cell.
+///
+/// Note on notation of the variables:
+///
+/// Concatenation of a and b is represented by a_b
+/// Element-wise dot product of a and b is represented by ab
+/// Element-wise dot product is represented by \circ
+/// Matrix multiplication is represented by *
+///
+/// Biases are initialized with :
+/// `b_ru` - constant_initializer(1.0)
+/// `b_c` - constant_initializer(0.0)
+///
+/// This kernel op implements the following mathematical equations:
+///
+/// ```
+/// x_h_prev = [x, h_prev]
+///
+/// [r_bar u_bar] = x_h_prev * w_ru + b_ru
+///
+/// r = sigmoid(r_bar)
+/// u = sigmoid(u_bar)
+///
+/// h_prevr = h_prev \circ r
+///
+/// x_h_prevr = [x h_prevr]
+///
+/// c_bar = x_h_prevr * w_c + b_c
+/// c = tanh(c_bar)
+///
+/// h = (1-u) \circ c + u \circ h_prev
+/// ```
+@inlinable @inline(__always)
+public static func gRUBlockCell<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  hPrev: Tensor<T>,
+  wRu: Tensor<T>,
+  wC: Tensor<T>,
+  bRu: Tensor<T>,
+  bC: Tensor<T>
+) -> (r: Tensor<T>, u: Tensor<T>, c: Tensor<T>, h: Tensor<T>) {
+  let op = TFE_Op("GRUBlockCell")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(hPrev)
+  let _ = op.addInput(wRu)
+  let _ = op.addInput(wC)
+  let _ = op.addInput(bRu)
+  let _ = op.addInput(bC)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Computes the GRU cell back-propagation for 1 time step.
+///
+/// Args
+///     x: Input to the GRU cell.
+///     h_prev: State input from the previous GRU cell.
+///     w_ru: Weight matrix for the reset and update gate.
+///     w_c: Weight matrix for the cell connection gate.
+///     b_ru: Bias vector for the reset and update gate.
+///     b_c: Bias vector for the cell connection gate.
+///     r: Output of the reset gate.
+///     u: Output of the update gate.
+///     c: Output of the cell connection gate.
+///     d_h: Gradients of the h_new wrt to objective function.
+///
+/// Returns
+///     d_x: Gradients of the x wrt to objective function.
+///     d_h_prev: Gradients of the h wrt to objective function.
+///     d_c_bar Gradients of the c_bar wrt to objective function.
+///     d_r_bar_u_bar Gradients of the r_bar & u_bar wrt to objective function.
+///
+/// This kernel op implements the following mathematical equations:
+///
+/// Note on notation of the variables:
+///
+/// Concatenation of a and b is represented by a_b
+/// Element-wise dot product of a and b is represented by ab
+/// Element-wise dot product is represented by \circ
+/// Matrix multiplication is represented by *
+///
+/// Additional notes for clarity:
+///
+/// `w_ru` can be segmented into 4 different matrices.
+/// ```
+/// w_ru = [w_r_x w_u_x
+///         w_r_h_prev w_u_h_prev]
+/// ```
+/// Similarly, `w_c` can be segmented into 2 different matrices.
+/// ```
+/// w_c = [w_c_x w_c_h_prevr]
+/// ```
+/// Same goes for biases.
+/// ```
+/// b_ru = [b_ru_x b_ru_h]
+/// b_c = [b_c_x b_c_h]
+/// ```
+/// Another note on notation:
+/// ```
+/// d_x = d_x_component_1 + d_x_component_2
+///
+/// where d_x_component_1 = d_r_bar * w_r_x^T + d_u_bar * w_r_x^T
+/// and d_x_component_2 = d_c_bar * w_c_x^T
+///
+/// d_h_prev = d_h_prev_component_1 + d_h_prevr \circ r + d_h \circ u
+/// where d_h_prev_componenet_1 = d_r_bar * w_r_h_prev^T + d_u_bar * w_r_h_prev^T
+/// ```
+///
+/// Mathematics behind the Gradients below:
+/// ```
+/// d_c_bar = d_h \circ (1-u) \circ (1-c \circ c)
+/// d_u_bar = d_h \circ (h-c) \circ u \circ (1-u)
+///
+/// d_r_bar_u_bar = [d_r_bar d_u_bar]
+///
+/// [d_x_component_1 d_h_prev_component_1] = d_r_bar_u_bar * w_ru^T
+///
+/// [d_x_component_2 d_h_prevr] = d_c_bar * w_c^T
+///
+/// d_x = d_x_component_1 + d_x_component_2
+///
+/// d_h_prev = d_h_prev_component_1 + d_h_prevr \circ r + u
+/// ```
+/// Below calculation is performed in the python wrapper for the Gradients
+/// (not in the gradient kernel.)
+/// ```
+/// d_w_ru = x_h_prevr^T * d_c_bar
+///
+/// d_w_c = x_h_prev^T * d_r_bar_u_bar
+///
+/// d_b_ru = sum of d_r_bar_u_bar along axis = 0
+///
+/// d_b_c = sum of d_c_bar along axis = 0
+/// ```
+@inlinable @inline(__always)
+public static func gRUBlockCellGrad<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  hPrev: Tensor<T>,
+  wRu: Tensor<T>,
+  wC: Tensor<T>,
+  bRu: Tensor<T>,
+  bC: Tensor<T>,
+  r: Tensor<T>,
+  u: Tensor<T>,
+  c: Tensor<T>,
+  dH: Tensor<T>
+) -> (dX: Tensor<T>, dHPrev: Tensor<T>, dCBar: Tensor<T>, dRBarUBar: Tensor<T>) {
+  let op = TFE_Op("GRUBlockCellGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(hPrev)
+  let _ = op.addInput(wRu)
+  let _ = op.addInput(wC)
+  let _ = op.addInput(bRu)
+  let _ = op.addInput(bC)
+  let _ = op.addInput(r)
+  let _ = op.addInput(u)
+  let _ = op.addInput(c)
+  let _ = op.addInput(dH)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Gather slices from `params` according to `indices`.
+///
+/// `indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
+/// Produces an output tensor with shape `indices.shape + params.shape[1:]` where:
+///
+/// ```python
+///     # Scalar indices
+///     output[:, ..., :] = params[indices, :, ... :]
+///
+///     # Vector indices
+///     output[i, :, ..., :] = params[indices[i], :, ... :]
+///
+///     # Higher rank indices
+///     output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
+/// ```
+///
+/// If `indices` is a permutation and `len(indices) == params.shape[0]` then
+/// this operation will permute `params` accordingly.
+///
+/// `validate_indices`: DEPRECATED. If this operation is assigned to CPU, values in
+/// `indices` are always validated to be within range. If assigned to GPU,
+/// out-of-bound indices result in safe but unspecified behavior, which may include
+/// raising an error.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
+/// </div>
+@inlinable @inline(__always)
+public static func gather<
+    Tparams: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  params: Tensor<Tparams>,
+  indices: Tensor<Tindices>,
+  validateIndices: Bool = true
+) -> Tensor<Tparams> {
+  let op = TFE_Op("Gather")
+  op.setAttr("validate_indices", validateIndices)
+  op.setAttr("Tparams", Tparams.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(params)
+  let _ = op.addInput(indices)
+  return op.execute(Int(1))
+}
+
+/// Gather slices from `params` into a Tensor with shape specified by `indices`.
+///
+/// `indices` is an K-dimensional integer tensor, best thought of as a
+/// (K-1)-dimensional tensor of indices into `params`, where each element defines a
+/// slice of `params`:
+///
+///     output[\\(i_0, ..., i_{K-2}\\)] = params[indices[\\(i_0, ..., i_{K-2}\\)]]
+///
+/// Whereas in `tf.gather` `indices` defines slices into the first
+/// dimension of `params`, in `tf.gather_nd`, `indices` defines slices into the
+/// first `N` dimensions of `params`, where `N = indices.shape[-1]`.
+///
+/// The last dimension of `indices` can be at most the rank of
+/// `params`:
+///
+///     indices.shape[-1] <= params.rank
+///
+/// The last dimension of `indices` corresponds to elements
+/// (if `indices.shape[-1] == params.rank`) or slices
+/// (if `indices.shape[-1] < params.rank`) along dimension `indices.shape[-1]`
+/// of `params`.  The output tensor has shape
+///
+///     indices.shape[:-1] + params.shape[indices.shape[-1]:]
+///
+/// Note that on CPU, if an out of bound index is found, an error is returned.
+/// On GPU, if an out of bound index is found, a 0 is stored in the
+/// corresponding output value.
+///
+/// Some examples below.
+///
+/// Simple indexing into a matrix:
+///
+/// ```python
+///     indices = [[0, 0], [1, 1]]
+///     params = [['a', 'b'], ['c', 'd']]
+///     output = ['a', 'd']
+/// ```
+///
+/// Slice indexing into a matrix:
+///
+/// ```python
+///     indices = [[1], [0]]
+///     params = [['a', 'b'], ['c', 'd']]
+///     output = [['c', 'd'], ['a', 'b']]
+/// ```
+///
+/// Indexing into a 3-tensor:
+///
+/// ```python
+///     indices = [[1]]
+///     params = [[['a0', 'b0'], ['c0', 'd0']],
+///               [['a1', 'b1'], ['c1', 'd1']]]
+///     output = [[['a1', 'b1'], ['c1', 'd1']]]
+///
+///
+///     indices = [[0, 1], [1, 0]]
+///     params = [[['a0', 'b0'], ['c0', 'd0']],
+///               [['a1', 'b1'], ['c1', 'd1']]]
+///     output = [['c0', 'd0'], ['a1', 'b1']]
+///
+///
+///     indices = [[0, 0, 1], [1, 0, 1]]
+///     params = [[['a0', 'b0'], ['c0', 'd0']],
+///               [['a1', 'b1'], ['c1', 'd1']]]
+///     output = ['b0', 'b1']
+/// ```
+///
+/// Batched indexing into a matrix:
+///
+/// ```python
+///     indices = [[[0, 0]], [[0, 1]]]
+///     params = [['a', 'b'], ['c', 'd']]
+///     output = [['a'], ['b']]
+/// ```
+///
+/// Batched slice indexing into a matrix:
+///
+/// ```python
+///     indices = [[[1]], [[0]]]
+///     params = [['a', 'b'], ['c', 'd']]
+///     output = [[['c', 'd']], [['a', 'b']]]
+/// ```
+///
+/// Batched indexing into a 3-tensor:
+///
+/// ```python
+///     indices = [[[1]], [[0]]]
+///     params = [[['a0', 'b0'], ['c0', 'd0']],
+///               [['a1', 'b1'], ['c1', 'd1']]]
+///     output = [[[['a1', 'b1'], ['c1', 'd1']]],
+///               [[['a0', 'b0'], ['c0', 'd0']]]]
+///
+///     indices = [[[0, 1], [1, 0]], [[0, 0], [1, 1]]]
+///     params = [[['a0', 'b0'], ['c0', 'd0']],
+///               [['a1', 'b1'], ['c1', 'd1']]]
+///     output = [[['c0', 'd0'], ['a1', 'b1']],
+///               [['a0', 'b0'], ['c1', 'd1']]]
+///
+///
+///     indices = [[[0, 0, 1], [1, 0, 1]], [[0, 1, 1], [1, 1, 0]]]
+///     params = [[['a0', 'b0'], ['c0', 'd0']],
+///               [['a1', 'b1'], ['c1', 'd1']]]
+///     output = [['b0', 'b1'], ['d0', 'c1']]
+/// ```
+///
+/// See also `tf.gather` and `tf.batch_gather`.
+///
+/// - Parameters:
+///   - params: The tensor from which to gather values.
+///   - indices: Index tensor.
+///
+/// - Output output: Values from `params` gathered from indices given by `indices`, with
+///   shape `indices.shape[:-1] + params.shape[indices.shape[-1]:]`.
+@inlinable @inline(__always)
+public static func gatherNd<
+    Tparams: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  params: Tensor<Tparams>,
+  indices: Tensor<Tindices>
+) -> Tensor<Tparams> {
+  let op = TFE_Op("GatherNd")
+  op.setAttr("Tparams", Tparams.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(params)
+  let _ = op.addInput(indices)
+  return op.execute(Int(1))
+}
+
+/// Gather slices from `params` axis `axis` according to `indices`.
+///
+/// `indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
+/// Produces an output tensor with shape `params.shape[:axis] + indices.shape +
+/// params.shape[axis + 1:]` where:
+///
+/// ```python
+///     # Scalar indices (output is rank(params) - 1).
+///     output[a_0, ..., a_n, b_0, ..., b_n] =
+///       params[a_0, ..., a_n, indices, b_0, ..., b_n]
+///
+///     # Vector indices (output is rank(params)).
+///     output[a_0, ..., a_n, i, b_0, ..., b_n] =
+///       params[a_0, ..., a_n, indices[i], b_0, ..., b_n]
+///
+///     # Higher rank indices (output is rank(params) + rank(indices) - 1).
+///     output[a_0, ..., a_n, i, ..., j, b_0, ... b_n] =
+///       params[a_0, ..., a_n, indices[i, ..., j], b_0, ..., b_n]
+/// ```
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
+/// </div>
+///
+/// Note that on CPU, if an out of bound index is found, an error is returned.
+/// On GPU, if an out of bound index is found, a 0 is stored in the
+/// corresponding output value.
+///
+/// See also `tf.batch_gather` and `tf.gather_nd`.
+///
+/// - Parameters:
+///   - params: The tensor from which to gather values. Must be at least rank
+///     `axis + 1`.
+///   - indices: Index tensor. Must be in range `[0, params.shape[axis])`.
+///   - axis: The axis in `params` to gather `indices` from. Defaults to the first
+///     dimension. Supports negative indexes.
+///
+/// - Output output: Values from `params` gathered from indices given by `indices`, with
+///   shape `params.shape[:axis] + indices.shape + params.shape[axis + 1:]`.
+@inlinable @inline(__always)
+public static func gatherV2<
+    Tparams: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar,
+    Taxis: BinaryInteger & TensorFlowScalar
+>(
+  params: Tensor<Tparams>,
+  indices: Tensor<Tindices>,
+  axis: Tensor<Taxis>
+) -> Tensor<Tparams> {
+  let op = TFE_Op("GatherV2")
+  op.setAttr("Tparams", Tparams.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("Taxis", Taxis.tensorFlowDataType)
+  let _ = op.addInput(params)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(axis)
+  return op.execute(Int(1))
+}
+
+/// Re-configures the GCS block cache with the new configuration values.
+///
+/// If the values are the same as already configured values, this op is a no-op. If
+/// they are different, the current contents of the block cache is dropped, and a
+/// new block cache is created fresh.
+@inlinable @inline(__always)
+public static func gcsConfigureBlockCache(
+  maxCacheSize: Tensor<UInt64>,
+  blockSize: Tensor<UInt64>,
+  maxStaleness: Tensor<UInt64>
+) {
+  let op = TFE_Op("GcsConfigureBlockCache")
+  let _ = op.addInput(maxCacheSize)
+  let _ = op.addInput(blockSize)
+  let _ = op.addInput(maxStaleness)
+  op.execute()
+}
+
+/// Configures the credentials used by the GCS client of the local TF runtime.
+///
+/// The json input can be of the format:
+///
+/// 1. Refresh Token:
+/// {
+///   "client_id": "<redacted>",
+///   "client_secret": "<redacted>",
+///   "refresh_token: "<redacted>",
+///   "type": "authorized_user",
+/// }
+///
+/// 2. Service Account:
+/// {
+///   "type": "service_account",
+///   "project_id": "<redacted>",
+///   "private_key_id": "<redacted>",
+///   "private_key": "------BEGIN PRIVATE KEY-----\n<REDACTED>\n-----END PRIVATE KEY------\n",
+///   "client_email": "<REDACTED>@<REDACTED>.iam.gserviceaccount.com",
+///   "client_id": "<REDACTED>",
+///   # Some additional fields elided
+/// }
+///
+/// Note the credentials established through this method are shared across all
+/// sessions run on this runtime.
+///
+/// Note be sure to feed the inputs to this op to ensure the credentials are not
+/// stored in a constant op within the graph that might accidentally be checkpointed
+/// or in other ways be persisted or exfiltrated.
+@inlinable @inline(__always)
+public static func gcsConfigureCredentials(
+  json: StringTensor
+) {
+  let op = TFE_Op("GcsConfigureCredentials")
+  let _ = op.addInput(json)
+  op.execute()
+}
+
+/// Generates serialized partition messages suitable for batch reads.
+///
+/// This op should not be used directly by clients. Instead, the
+/// bigquery_reader_ops.py file defines a clean interface to the reader.
+///
+/// - Attrs:
+///   - project_id: GCP project ID.
+///   - dataset_id: BigQuery Dataset ID.
+///   - table_id: Table to read.
+///   - columns: List of columns to read. Leave empty to read all columns.
+///   - timestamp_millis: Table snapshot timestamp in millis since epoch. Relative
+///     (negative or zero) snapshot times are not allowed. For more details, see
+///     'Table Decorators' in BigQuery docs.
+///   - num_partitions: Number of partitions to split the table into.
+///   - test_end_point: Do not use. For testing purposes only.
+///
+/// - Output partitions: Serialized table partitions.
+@inlinable @inline(__always)
+public static func generateBigQueryReaderPartitions(
+  projectId: String,
+  datasetId: String,
+  tableId: String,
+  columns: [String],
+  timestampMillis: Int64,
+  numPartitions: Int64,
+  testEndPoint: String
+) -> StringTensor {
+  let op = TFE_Op("GenerateBigQueryReaderPartitions")
+  op.setAttr("project_id", projectId)
+  op.setAttr("dataset_id", datasetId)
+  op.setAttr("table_id", tableId)
+  op.setAttr("columns", columns)
+  op.setAttr("timestamp_millis", timestampMillis)
+  op.setAttr("num_partitions", numPartitions)
+  op.setAttr("test_end_point", testEndPoint)
+  return op.execute(Int(1))
+}
+
+/// Given a path to new and old vocabulary files, returns a remapping Tensor of
+///
+/// length `num_new_vocab`, where `remapping[i]` contains the row number in the old
+/// vocabulary that corresponds to row `i` in the new vocabulary (starting at line
+/// `new_vocab_offset` and up to `num_new_vocab` entities), or `-1` if entry `i`
+/// in the new vocabulary is not in the old vocabulary.  The old vocabulary is
+/// constrained to the first `old_vocab_size` entries if `old_vocab_size` is not the
+/// default value of -1.
+///
+/// `num_vocab_offset` enables
+/// use in the partitioned variable case, and should generally be set through
+/// examining partitioning info.  The format of the files should be a text file,
+/// with each line containing a single entity within the vocabulary.
+///
+/// For example, with `new_vocab_file` a text file containing each of the following
+/// elements on a single line: `[f0, f1, f2, f3]`, old_vocab_file = [f1, f0, f3],
+/// `num_new_vocab = 3, new_vocab_offset = 1`, the returned remapping would be
+/// `[0, -1, 2]`.
+///
+/// The op also returns a count of how many entries in the new vocabulary
+/// were present in the old vocabulary, which is used to calculate the number of
+/// values to initialize in a weight matrix remapping
+///
+/// This functionality can be used to remap both row vocabularies (typically,
+/// features) and column vocabularies (typically, classes) from TensorFlow
+/// checkpoints.  Note that the partitioning logic relies on contiguous vocabularies
+/// corresponding to div-partitioned variables.  Moreover, the underlying remapping
+/// uses an IndexTable (as opposed to an inexact CuckooTable), so client code should
+/// use the corresponding index_table_from_file() as the FeatureColumn framework
+/// does (as opposed to tf.feature_to_id(), which uses a CuckooTable).
+///
+/// - Parameters:
+///   - new_vocab_file: Path to the new vocab file.
+///   - old_vocab_file: Path to the old vocab file.
+///
+/// - Attrs:
+///   - new_vocab_offset: How many entries into the new vocab file to start reading.
+///   - num_new_vocab: Number of entries in the new vocab file to remap.
+///   - old_vocab_size: Number of entries in the old vocab file to consider.  If -1,
+///     use the entire old vocabulary.
+///
+/// - Outputs:
+///   - remapping: A Tensor of length num_new_vocab where the element at index i
+///     is equal to the old ID that maps to the new ID i.  This element is -1 for any
+///     new ID that is not found in the old vocabulary.
+///   - num_present: Number of new vocab entries found in old vocab.
+@inlinable @inline(__always)
+public static func generateVocabRemapping(
+  newVocabFile: StringTensor,
+  oldVocabFile: StringTensor,
+  newVocabOffset: Int64,
+  numNewVocab: Int64,
+  oldVocabSize: Int64 = -1
+) -> (remapping: Tensor<Int64>, numPresent: Tensor<Int32>) {
+  let op = TFE_Op("GenerateVocabRemapping")
+  op.setAttr("new_vocab_offset", newVocabOffset)
+  op.setAttr("num_new_vocab", numNewVocab)
+  op.setAttr("old_vocab_size", oldVocabSize)
+  let _ = op.addInput(newVocabFile)
+  let _ = op.addInput(oldVocabFile)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Creates a dataset that invokes a function to generate elements.
+@inlinable @inline(__always)
+public static func generatorDataset<
+    InitfuncIn: TensorGroup,
+    InitfuncOut: TensorGroup,
+    NextfuncIn: TensorGroup,
+    NextfuncOut: TensorGroup,
+    FinalizefuncIn: TensorGroup,
+    FinalizefuncOut: TensorGroup,
+    TinitFuncArgs: TensorArrayProtocol,
+    TnextFuncArgs: TensorArrayProtocol,
+    TfinalizeFuncArgs: TensorArrayProtocol
+>(
+  initFuncOtherArgs: TinitFuncArgs,
+  nextFuncOtherArgs: TnextFuncArgs,
+  finalizeFuncOtherArgs: TfinalizeFuncArgs,
+  initFunc: (InitfuncIn) -> InitfuncOut,
+  nextFunc: (NextfuncIn) -> NextfuncOut,
+  finalizeFunc: (FinalizefuncIn) -> FinalizefuncOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("GeneratorDataset")
+  op.setAttr("init_func", initFunc)
+  op.setAttr("next_func", nextFunc)
+  op.setAttr("finalize_func", finalizeFunc)
+  op.setAttr("Tinit_func_args", initFuncOtherArgs._typeList)
+  op.setAttr("Tnext_func_args", nextFuncOtherArgs._typeList)
+  op.setAttr("Tfinalize_func_args", finalizeFuncOtherArgs._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInputList(initFuncOtherArgs)
+  let _ = op.addInputList(nextFuncOtherArgs)
+  let _ = op.addInputList(finalizeFuncOtherArgs)
+  return op.execute(Int(1))
+}
+
+/// Store the input tensor in the state of the current session.
+///
+/// - Parameter value: The tensor to be stored.
+///
+/// - Output handle: The handle for the tensor stored in the session state, represented
+///   as a string.
+@inlinable @inline(__always)
+public static func getSessionHandle<T: TensorFlowScalar>(
+  value: Tensor<T>
+) -> StringTensor {
+  let op = TFE_Op("GetSessionHandle")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(value)
+  return op.execute(Int(1))
+}
+
+/// Store the input tensor in the state of the current session.
+///
+/// - Parameter value: The tensor to be stored.
+///
+/// - Output handle: The handle for the tensor stored in the session state, represented
+///   as a ResourceHandle object.
+@inlinable @inline(__always)
+public static func getSessionHandleV2<T: TensorFlowScalar>(
+  value: Tensor<T>
+) -> ResourceHandle {
+  let op = TFE_Op("GetSessionHandleV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(value)
+  return op.execute(Int(1))
+}
+
+/// Get the value of the tensor specified by its handle.
+///
+/// - Parameter handle: The handle for a tensor stored in the session state.
+///
+/// - Attr dtype: The type of the output value.
+///
+/// - Output value: The tensor for the given handle.
+@inlinable @inline(__always)
+public static func getSessionTensor<Dtype: TensorFlowScalar>(
+  handle: StringTensor
+) -> Tensor<Dtype> {
+  let op = TFE_Op("GetSessionTensor")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(handle)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func graphDefVersion(
+) -> Tensor<Int32> {
+  let op = TFE_Op("GraphDefVersion")
+  
+  return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x > y) element-wise.
+///
+/// *NOTE*: `Greater` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func greater<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<Bool> {
+  let op = TFE_Op("Greater")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x >= y) element-wise.
+///
+/// *NOTE*: `GreaterEqual` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func greaterEqual<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<Bool> {
+  let op = TFE_Op("GreaterEqual")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Gives a guarantee to the TF runtime that the input tensor is a constant.
+///
+/// The runtime is then free to make optimizations based on this.
+///
+/// Only accepts value typed tensors as inputs and rejects resource variable handles
+/// as input.
+///
+/// Returns the input tensor without modification.
+@inlinable @inline(__always)
+public static func guaranteeConst<T: TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("GuaranteeConst")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Convert one or more images from HSV to RGB.
+///
+/// Outputs a tensor of the same shape as the `images` tensor, containing the RGB
+/// value of the pixels. The output is only well defined if the value in `images`
+/// are in `[0,1]`.
+///
+/// See `rgb_to_hsv` for a description of the HSV encoding.
+///
+/// - Parameter images: 1-D or higher rank. HSV data to convert. Last dimension must be size 3.
+///
+/// - Output output: `images` converted to RGB.
+@inlinable @inline(__always)
+public static func hSVToRGB<T: FloatingPoint & TensorFlowScalar>(
+  images: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("HSVToRGB")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(images)
+  return op.execute(Int(1))
+}
+
+/// Creates a non-initialized hash table.
+///
+/// This op creates a hash table, specifying the type of its keys and values.
+/// Before using the table you will have to initialize it.  After initialization the
+/// table will be immutable.
+///
+/// - Attrs:
+///   - container: If non-empty, this table is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this table is shared under the given name across
+///     multiple sessions.
+///   - use_node_name_sharing: If true and shared_name is empty, the table is shared
+///     using the node name.
+///   - key_dtype: Type of the table keys.
+///   - value_dtype: Type of the table values.
+///
+/// - Output table_handle: Handle to a table.
+@inlinable @inline(__always)
+public static func hashTableV2(
+  container: String,
+  sharedName: String,
+  useNodeNameSharing: Bool = false,
+  keyDtype: TensorDataType,
+  valueDtype: TensorDataType
+) -> ResourceHandle {
+  let op = TFE_Op("HashTableV2")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("use_node_name_sharing", useNodeNameSharing)
+  op.setAttr("key_dtype", keyDtype)
+  op.setAttr("value_dtype", valueDtype)
+  return op.execute(Int(1))
+}
+
+/// Return histogram of values.
+///
+/// Given the tensor `values`, this operation returns a rank 1 histogram counting
+/// the number of entries in `values` that fall into every bin.  The bins are
+/// equal width and determined by the arguments `value_range` and `nbins`.
+///
+/// ```python
+/// # Bins will be:  (-inf, 1), [1, 2), [2, 3), [3, 4), [4, inf)
+/// nbins = 5
+/// value_range = [0.0, 5.0]
+/// new_values = [-1.0, 0.0, 1.5, 2.0, 5.0, 15]
+///
+/// with tf.get_default_session() as sess:
+///   hist = tf.histogram_fixed_width(new_values, value_range, nbins=5)
+///   variables.global_variables_initializer().run()
+///   sess.run(hist) => [2, 1, 1, 0, 2]
+/// ```
+///
+/// - Parameters:
+///   - values: Numeric `Tensor`.
+///   - value_range: Shape [2] `Tensor` of same `dtype` as `values`.
+///     values <= value_range[0] will be mapped to hist[0],
+///     values >= value_range[1] will be mapped to hist[-1].
+///   - nbins: Scalar `int32 Tensor`.  Number of histogram bins.
+///
+/// - Output out: A 1-D `Tensor` holding histogram of values.
+@inlinable @inline(__always)
+public static func histogramFixedWidth<
+    T: Numeric & TensorFlowScalar,
+    Dtype: BinaryInteger & TensorFlowScalar
+>(
+  _ values: Tensor<T>,
+  valueRange: Tensor<T>,
+  nbins: Tensor<Int32>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("HistogramFixedWidth")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(values)
+  let _ = op.addInput(valueRange)
+  let _ = op.addInput(nbins)
+  return op.execute(Int(1))
+}
+
+/// Outputs a `Summary` protocol buffer with a histogram.
+///
+/// The generated
+/// [`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto)
+/// has one summary value containing a histogram for `values`.
+///
+/// This op reports an `InvalidArgument` error if any value is not finite.
+///
+/// - Parameters:
+///   - tag: Scalar.  Tag to use for the `Summary.Value`.
+///   - values: Any shape. Values to use to build the histogram.
+///
+/// - Output summary: Scalar. Serialized `Summary` protocol buffer.
+@inlinable @inline(__always)
+public static func histogramSummary<T: Numeric & TensorFlowScalar>(
+  tag: StringTensor,
+  _ values: Tensor<T>
+) -> StringTensor {
+  let op = TFE_Op("HistogramSummary")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(tag)
+  let _ = op.addInput(values)
+  return op.execute(Int(1))
+}
+
+/// Inverse fast Fourier transform.
+///
+/// Computes the inverse 1-dimensional discrete Fourier transform over the
+/// inner-most dimension of `input`.
+///
+/// - Parameter input: A complex tensor.
+///
+/// - Output output: A complex tensor of the same shape as `input`. The inner-most
+///     dimension of `input` is replaced with its inverse 1D Fourier transform.
+///
+///   @compatibility(numpy)
+///   Equivalent to np.fft.ifft
+///   @end_compatibility
+@inlinable @inline(__always)
+public static func iFFT<Tcomplex: TensorFlowScalar>(
+  _ input: Tensor<Tcomplex>
+) -> Tensor<Tcomplex> {
+  let op = TFE_Op("IFFT")
+  op.setAttr("Tcomplex", Tcomplex.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Inverse 2D fast Fourier transform.
+///
+/// Computes the inverse 2-dimensional discrete Fourier transform over the
+/// inner-most 2 dimensions of `input`.
+///
+/// - Parameter input: A complex tensor.
+///
+/// - Output output: A complex tensor of the same shape as `input`. The inner-most 2
+///     dimensions of `input` are replaced with their inverse 2D Fourier transform.
+///
+///   @compatibility(numpy)
+///   Equivalent to np.fft.ifft2
+///   @end_compatibility
+@inlinable @inline(__always)
+public static func iFFT2D<Tcomplex: TensorFlowScalar>(
+  _ input: Tensor<Tcomplex>
+) -> Tensor<Tcomplex> {
+  let op = TFE_Op("IFFT2D")
+  op.setAttr("Tcomplex", Tcomplex.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Inverse 3D fast Fourier transform.
+///
+/// Computes the inverse 3-dimensional discrete Fourier transform over the
+/// inner-most 3 dimensions of `input`.
+///
+/// - Parameter input: A complex64 tensor.
+///
+/// - Output output: A complex64 tensor of the same shape as `input`. The inner-most 3
+///     dimensions of `input` are replaced with their inverse 3D Fourier transform.
+///
+///   @compatibility(numpy)
+///   Equivalent to np.fft.ifftn with 3 dimensions.
+///   @end_compatibility
+@inlinable @inline(__always)
+public static func iFFT3D<Tcomplex: TensorFlowScalar>(
+  _ input: Tensor<Tcomplex>
+) -> Tensor<Tcomplex> {
+  let op = TFE_Op("IFFT3D")
+  op.setAttr("Tcomplex", Tcomplex.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Return a tensor with the same shape and contents as the input tensor or value.
+@inlinable @inline(__always)
+public static func identity<T: TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Identity")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Returns a list of tensors with the same shapes and contents as the input
+///
+/// tensors.
+///
+/// This op can be used to override the gradient for complicated functions. For
+/// example, suppose y = f(x) and we wish to apply a custom function g for backprop
+/// such that dx = g(dy). In Python,
+///
+/// ```python
+/// with tf.get_default_graph().gradient_override_map(
+///     {'IdentityN': 'OverrideGradientWithG'}):
+///   y, _ = identity_n([f(x), x])
+///
+/// @tf.RegisterGradient('OverrideGradientWithG')
+/// def ApplyG(op, dy, _):
+///   return [None, g(dy)]  # Do not backprop to f(x).
+/// ```
+@inlinable @inline(__always)
+public static func identityN<T: TensorArrayProtocol>(
+  _ input: T
+) -> T {
+  let op = TFE_Op("IdentityN")
+  op.setAttr("T", input._typeList)
+  let _ = op.addInputList(input)
+  return op.execute(Int(input._typeList.count))
+}
+
+/// A Reader that outputs the queued work as both the key and value.
+///
+/// To use, enqueue strings in a Queue.  ReaderRead will take the front
+/// work string and output (work, work).
+///
+/// - Attrs:
+///   - container: If non-empty, this reader is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this reader is named in the given bucket
+///     with this shared_name. Otherwise, the node name is used instead.
+///
+/// - Output reader_handle: The handle to reference the Reader.
+@inlinable @inline(__always)
+public static func identityReaderV2(
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("IdentityReaderV2")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// output = cond ? then_branch(input) : else_branch(input)
+///
+/// - Parameters:
+///   - cond:       A Tensor. If the tensor is a scalar of non-boolean type, the
+///           scalar is converted to a boolean according to the
+///           following rule: if the scalar is a numerical value, non-zero means
+///           `True` and zero means False; if the scalar is a string, non-empty
+///           means `True` and empty means `False`. If the tensor is not a scalar,
+///           being empty means False and being non-empty means True.
+///   - input: A list of input tensors.
+///
+/// - Attrs:
+///   - Tin: A list of input types.
+///   - Tout: A list of output types.
+///   - then_branch:       A function that takes 'inputs' and returns a list of tensors, whose
+///           types are the same as what else_branch returns.
+///   - else_branch:     A function that takes 'inputs' and returns a list of tensors, whose
+///         types are the same as what then_branch returns.
+///
+/// - Output output: A list of return values.
+@inlinable @inline(__always)
+public static func if_<
+    Tcond: TensorFlowScalar,
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    ThenbranchIn: TensorGroup,
+    ThenbranchOut: TensorGroup,
+    ElsebranchIn: TensorGroup,
+    ElsebranchOut: TensorGroup
+>(
+  cond: Tensor<Tcond>,
+  _ input: Tin,
+  thenBranch: (ThenbranchIn) -> ThenbranchOut,
+  elseBranch: (ElsebranchIn) -> ElsebranchOut,
+  outputShapes: [TensorShape?]
+) -> Tout {
+  let op = TFE_Op("If")
+  op.setAttr("Tcond", Tcond.tensorFlowDataType)
+  op.setAttr("Tin", input._typeList)
+  op.setAttr("Tout", Tout._typeList)
+  op.setAttr("then_branch", thenBranch)
+  op.setAttr("else_branch", elseBranch)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(cond)
+  let _ = op.addInputList(input)
+  return op.execute(Int(Tout._typeList.count))
+}
+
+/// Compute the lower regularized incomplete Gamma function `P(a, x)`.
+///
+/// The lower regularized incomplete Gamma function is defined as:
+///
+///
+/// \\(P(a, x) = gamma(a, x) / Gamma(a) = 1 - Q(a, x)\\)
+///
+/// where
+///
+/// \\(gamma(a, x) = \\int_{0}^{x} t^{a-1} exp(-t) dt\\)
+///
+/// is the lower incomplete Gamma function.
+///
+/// Note, above `Q(a, x)` (`Igammac`) is the upper regularized complete
+/// Gamma function.
+@inlinable @inline(__always)
+public static func igamma<T: FloatingPoint & TensorFlowScalar>(
+  _ a: Tensor<T>,
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Igamma")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient of `igamma(a, x)` wrt `a`.
+@inlinable @inline(__always)
+public static func igammaGradA<T: FloatingPoint & TensorFlowScalar>(
+  _ a: Tensor<T>,
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("IgammaGradA")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Compute the upper regularized incomplete Gamma function `Q(a, x)`.
+///
+/// The upper regularized incomplete Gamma function is defined as:
+///
+/// \\(Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)\\)
+///
+/// where
+///
+/// \\(Gamma(a, x) = int_{x}^{\infty} t^{a-1} exp(-t) dt\\)
+///
+/// is the upper incomplete Gama function.
+///
+/// Note, above `P(a, x)` (`Igamma`) is the lower regularized complete
+/// Gamma function.
+@inlinable @inline(__always)
+public static func igammac<T: FloatingPoint & TensorFlowScalar>(
+  _ a: Tensor<T>,
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Igammac")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns the imaginary part of a complex number.
+///
+/// Given a tensor `input` of complex numbers, this operation returns a tensor of
+/// type `float` that is the imaginary part of each element in `input`. All
+/// elements in `input` must be complex numbers of the form \\(a + bj\\), where *a*
+/// is the real part and *b* is the imaginary part returned by this operation.
+///
+/// For example:
+///
+/// ```
+/// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
+/// tf.imag(input) ==> [4.75, 5.75]
+/// ```
+@inlinable @inline(__always)
+public static func imag<
+    T: TensorFlowScalar,
+    Tout: FloatingPoint & TensorFlowScalar
+>(
+  _ input: Tensor<T>
+) -> Tensor<Tout> {
+  let op = TFE_Op("Imag")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tout", Tout.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Returns immutable tensor from memory region.
+///
+/// The current implementation memmaps the tensor from a file.
+///
+/// - Attrs:
+///   - dtype: Type of the returned tensor.
+///   - shape: Shape of the returned tensor.
+///   - memory_region_name: Name of readonly memory region used by the tensor, see
+///     NewReadOnlyMemoryRegionFromFile in tensorflow::Env.
+@inlinable @inline(__always)
+public static func immutableConst<Dtype: TensorFlowScalar>(
+  shape: TensorShape?,
+  memoryRegionName: String
+) -> Tensor<Dtype> {
+  let op = TFE_Op("ImmutableConst")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape", shape)
+  op.setAttr("memory_region_name", memoryRegionName)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func importEvent(
+  writer: ResourceHandle,
+  event: StringTensor
+) {
+  let op = TFE_Op("ImportEvent")
+  let _ = op.addInput(writer)
+  let _ = op.addInput(event)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func inPolymorphicTwice<T: TensorFlowScalar>(
+  _ a: [Tensor<T>],
+  _ b: [Tensor<T>]
+) {
+  let op = TFE_Op("InPolymorphicTwice")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("N", a.count)
+  op.setAttr("M", b.count)
+  let _ = op.addInputList(a)
+  let _ = op.addInputList(b)
+  op.execute()
+}
+
+/// Says whether the targets are in the top `K` predictions.
+///
+/// This outputs a `batch_size` bool array, an entry `out[i]` is `true` if the
+/// prediction for the target class is among the top `k` predictions among
+/// all predictions for example `i`. Note that the behavior of `InTopK` differs
+/// from the `TopK` op in its handling of ties; if multiple classes have the
+/// same prediction value and straddle the top-`k` boundary, all of those
+/// classes are considered to be in the top `k`.
+///
+/// More formally, let
+///
+///   \\(predictions_i\\) be the predictions for all classes for example `i`,
+///   \\(targets_i\\) be the target class for example `i`,
+///   \\(out_i\\) be the output for example `i`,
+///
+/// $$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
+///
+/// - Parameters:
+///   - predictions: A `batch_size` x `classes` tensor.
+///   - targets: A `batch_size` vector of class ids.
+///
+/// - Attr k: Number of top elements to look at for computing precision.
+///
+/// - Output precision: Computed Precision at `k` as a `bool Tensor`.
+@inlinable @inline(__always)
+public static func inTopK<T: BinaryInteger & TensorFlowScalar>(
+  predictions: Tensor<Float>,
+  targets: Tensor<T>,
+  k: Int64
+) -> Tensor<Bool> {
+  let op = TFE_Op("InTopK")
+  op.setAttr("k", k)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(predictions)
+  let _ = op.addInput(targets)
+  return op.execute(Int(1))
+}
+
+/// Says whether the targets are in the top `K` predictions.
+///
+/// This outputs a `batch_size` bool array, an entry `out[i]` is `true` if the
+/// prediction for the target class is among the top `k` predictions among
+/// all predictions for example `i`. Note that the behavior of `InTopK` differs
+/// from the `TopK` op in its handling of ties; if multiple classes have the
+/// same prediction value and straddle the top-`k` boundary, all of those
+/// classes are considered to be in the top `k`.
+///
+/// More formally, let
+///
+///   \\(predictions_i\\) be the predictions for all classes for example `i`,
+///   \\(targets_i\\) be the target class for example `i`,
+///   \\(out_i\\) be the output for example `i`,
+///
+/// $$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
+///
+/// - Parameters:
+///   - predictions: A `batch_size` x `classes` tensor.
+///   - targets: A `batch_size` vector of class ids.
+///   - k: Number of top elements to look at for computing precision.
+///
+/// - Output precision: Computed precision at `k` as a `bool Tensor`.
+@inlinable @inline(__always)
+public static func inTopKV2<T: BinaryInteger & TensorFlowScalar>(
+  predictions: Tensor<Float>,
+  targets: Tensor<T>,
+  k: Tensor<T>
+) -> Tensor<Bool> {
+  let op = TFE_Op("InTopKV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(predictions)
+  let _ = op.addInput(targets)
+  let _ = op.addInput(k)
+  return op.execute(Int(1))
+}
+
+/// A placeholder op for a value that will be fed into the computation.
+///
+/// - Attrs:
+///   - dtype: The type of elements in the tensor.
+///   - shape: The shape of the tensor.
+///
+/// - Output output: A tensor that will be provided using the infeed mechanism.
+@inlinable @inline(__always)
+public static func infeedDequeue<Dtype: TensorFlowScalar>(
+  shape: TensorShape?
+) -> Tensor<Dtype> {
+  let op = TFE_Op("InfeedDequeue")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape", shape)
+  return op.execute(Int(1))
+}
+
+/// Fetches multiple values from infeed as an XLA tuple.
+///
+/// - Attrs:
+///   - dtypes: The element types of each element in `outputs`.
+///   - shapes: The shapes of each tensor in `outputs`.
+///
+/// - Output outputs: A list of tensors that will be provided using the infeed mechanism.
+@inlinable @inline(__always)
+public static func infeedDequeueTuple<Dtypes: TensorGroup>(
+  shapes: [TensorShape?]
+) -> Dtypes {
+  let op = TFE_Op("InfeedDequeueTuple")
+  op.setAttr("dtypes", Dtypes._typeList)
+  op.setAttr("shapes", shapes)
+  return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// An op which feeds a single Tensor value into the computation.
+///
+/// - Parameter input: A tensor that will be provided using the infeed mechanism.
+///
+/// - Attrs:
+///   - dtype: The type of elements in the tensor.
+///   - shape: The shape of the tensor.
+///   - layout: A vector holding the requested layout in minor-to-major sequence.
+///     If a layout attribute is passed, but its values are all -1, the layout will
+///     be computed by the infeed operation.
+///   - device_ordinal: The TPU device to use. This should be -1 when the Op
+///     is running on a TPU device, and >= 0 when the Op is running on the CPU
+///     device.
+@inlinable @inline(__always)
+public static func infeedEnqueue<Dtype: TensorFlowScalar>(
+  _ input: Tensor<Dtype>,
+  shape: TensorShape?,
+  layout: [Int32],
+  deviceOrdinal: Int64 = -1
+) {
+  let op = TFE_Op("InfeedEnqueue")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape", shape)
+  op.setAttr("layout", layout)
+  op.setAttr("device_ordinal", deviceOrdinal)
+  let _ = op.addInput(input)
+  op.execute()
+}
+
+/// An op which enqueues prelinearized buffer into TPU infeed.
+///
+/// - Parameter input: A variant tensor representing linearized output.
+///
+/// - Attr device_ordinal: The TPU device to use. This should be -1 when the Op is running on a TPU device
+///   and = 0 when the Op is running on the CPU device.
+@inlinable @inline(__always)
+public static func infeedEnqueuePrelinearizedBuffer(
+  _ input: VariantHandle,
+  deviceOrdinal: Int64 = -1
+) {
+  let op = TFE_Op("InfeedEnqueuePrelinearizedBuffer")
+  op.setAttr("device_ordinal", deviceOrdinal)
+  let _ = op.addInput(input)
+  op.execute()
+}
+
+/// Feeds multiple Tensor values into the computation as an XLA tuple.
+///
+/// - Parameter inputs: A list of tensors that will be provided using the infeed mechanism.
+///
+/// - Attrs:
+///   - dtypes: The element types of each element in `inputs`.
+///   - shapes: The shapes of each tensor in `inputs`.
+///   - layouts: A vector holding the requested layout in minor-to-major sequence for
+///     all the tuple shapes, in the order the shapes appear in the "shapes" input.
+///     The layout elements for a sub-shape can be set to -1, in which case the
+///     corresponding layout will be computed by the infeed operation.
+///   - device_ordinal: The TPU device to use. This should be -1 when the Op
+///     is running on a TPU device, and >= 0 when the Op is running on the CPU
+///     device.
+@inlinable @inline(__always)
+public static func infeedEnqueueTuple<Dtypes: TensorArrayProtocol>(
+  inputs: Dtypes,
+  shapes: [TensorShape?],
+  layouts: [Int32],
+  deviceOrdinal: Int64 = -1
+) {
+  let op = TFE_Op("InfeedEnqueueTuple")
+  op.setAttr("dtypes", inputs._typeList)
+  op.setAttr("shapes", shapes)
+  op.setAttr("layouts", layouts)
+  op.setAttr("device_ordinal", deviceOrdinal)
+  let _ = op.addInputList(inputs)
+  op.execute()
+}
+
+/// Initializes a table from a text file.
+///
+/// It inserts one key-value pair into the table for each line of the file.
+/// The key and value is extracted from the whole line content, elements from the
+/// split line based on `delimiter` or the line number (starting from zero).
+/// Where to extract the key and value from a line is specified by `key_index` and
+/// `value_index`.
+///
+/// - A value of -1 means use the line number(starting from zero), expects `int64`.
+/// - A value of -2 means use the whole line content, expects `string`.
+/// - A value >= 0 means use the index (starting at zero) of the split line based
+///   on `delimiter`.
+///
+/// - Parameters:
+///   - table_handle: Handle to a table which will be initialized.
+///   - filename: Filename of a vocabulary text file.
+///
+/// - Attrs:
+///   - key_index: Column index in a line to get the table `key` values from.
+///   - value_index: Column index that represents information of a line to get the table
+///     `value` values from.
+///   - vocab_size: Number of elements of the file, use -1 if unknown.
+///   - delimiter: Delimiter to separate fields in a line.
+@inlinable @inline(__always)
+public static func initializeTableFromTextFileV2(
+  tableHandle: ResourceHandle,
+  filename: StringTensor,
+  keyIndex: Int64,
+  valueIndex: Int64,
+  vocabSize: Int64 = -1,
+  delimiter: String = "\t"
+) {
+  let op = TFE_Op("InitializeTableFromTextFileV2")
+  op.setAttr("key_index", keyIndex)
+  op.setAttr("value_index", valueIndex)
+  op.setAttr("vocab_size", vocabSize)
+  op.setAttr("delimiter", delimiter)
+  let _ = op.addInput(tableHandle)
+  let _ = op.addInput(filename)
+  op.execute()
+}
+
+/// Table initializer that takes two tensors for keys and values respectively.
+///
+/// - Parameters:
+///   - table_handle: Handle to a table which will be initialized.
+///   - keys: Keys of type Tkey.
+///   - values: Values of type Tval.
+@inlinable @inline(__always)
+public static func initializeTableV2<
+    Tkey: TensorFlowScalar,
+    Tval: TensorFlowScalar
+>(
+  tableHandle: ResourceHandle,
+  keys: Tensor<Tkey>,
+  _ values: Tensor<Tval>
+) {
+  let op = TFE_Op("InitializeTableV2")
+  op.setAttr("Tkey", Tkey.tensorFlowDataType)
+  op.setAttr("Tval", Tval.tensorFlowDataType)
+  let _ = op.addInput(tableHandle)
+  let _ = op.addInput(keys)
+  let _ = op.addInput(values)
+  op.execute()
+}
+
+///     Adds v into specified rows of x.
+///
+///     Computes y = x; y[i, :] += v; return y.
+///
+/// - Parameters:
+///   - x: A `Tensor` of type T.
+///   - i: A vector. Indices into the left-most dimension of `x`.
+///   - v: A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
+///
+/// - Output y: A `Tensor` of type T. An alias of `x`. The content of `y` is undefined if there are duplicates in `i`.
+@inlinable @inline(__always)
+public static func inplaceAdd<T: TensorFlowScalar>(
+  _ x: Tensor<T>,
+  i: Tensor<Int32>,
+  v: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("InplaceAdd")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(i)
+  let _ = op.addInput(v)
+  return op.execute(Int(1))
+}
+
+///     Subtracts `v` into specified rows of `x`.
+///
+///     Computes y = x; y[i, :] -= v; return y.
+///
+/// - Parameters:
+///   - x: A `Tensor` of type T.
+///   - i: A vector. Indices into the left-most dimension of `x`.
+///   - v: A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
+///
+/// - Output y: A `Tensor` of type T. An alias of `x`. The content of `y` is undefined if there are duplicates in `i`.
+@inlinable @inline(__always)
+public static func inplaceSub<T: TensorFlowScalar>(
+  _ x: Tensor<T>,
+  i: Tensor<Int32>,
+  v: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("InplaceSub")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(i)
+  let _ = op.addInput(v)
+  return op.execute(Int(1))
+}
+
+///     Updates specified rows with values in `v`.
+///
+///     Computes `x[i, :] = v; return x`.
+///
+/// - Parameters:
+///   - x: A tensor of type `T`.
+///   - i: A vector. Indices into the left-most dimension of `x`.
+///   - v: A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
+///
+/// - Output y: A `Tensor` of type T. An alias of `x`. The content of `y` is undefined if there are duplicates in `i`.
+@inlinable @inline(__always)
+public static func inplaceUpdate<T: TensorFlowScalar>(
+  _ x: Tensor<T>,
+  i: Tensor<Int32>,
+  v: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("InplaceUpdate")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(i)
+  let _ = op.addInput(v)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func int64Output(
+) -> Tensor<Int64> {
+  let op = TFE_Op("Int64Output")
+  
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func intAttr(
+  foo: Int64 = 1
+) -> Tensor<Int64> {
+  let op = TFE_Op("IntAttr")
+  op.setAttr("foo", foo)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func intInput(
+  _ a: Tensor<Int32>
+) {
+  let op = TFE_Op("IntInput")
+  let _ = op.addInput(a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func intInputFloatInput(
+  _ a: Tensor<Int32>,
+  _ b: Tensor<Float>
+) {
+  let op = TFE_Op("IntInputFloatInput")
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func intInputIntOutput(
+  _ a: Tensor<Int32>
+) -> Tensor<Int32> {
+  let op = TFE_Op("IntInputIntOutput")
+  let _ = op.addInput(a)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func intOutput(
+) -> Tensor<Int32> {
+  let op = TFE_Op("IntOutput")
+  
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func intOutputFloatOutput(
+) -> (a: Tensor<Int32>, b: Tensor<Float>) {
+  let op = TFE_Op("IntOutputFloatOutput")
+  
+  return op.execute(Int(1), Int(1))
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+///
+/// Unlike MapDataset, the `f` in InterleaveDataset is expected to return
+/// a Dataset variant, and InterleaveDataset will flatten successive
+/// results into a single Dataset. Unlike FlatMapDataset,
+/// InterleaveDataset will interleave sequences of up to `block_length`
+/// consecutive elements from `cycle_length` input elements.
+///
+/// - Attr f: A function mapping elements of `input_dataset`, concatenated with
+///   `other_arguments`, to a Dataset variant that contains elements matching
+///   `output_types` and `output_shapes`.
+@inlinable @inline(__always)
+public static func interleaveDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  otherArguments: Targuments,
+  cycleLength: Tensor<Int64>,
+  blockLength: Tensor<Int64>,
+  f: (FIn) -> FOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("InterleaveDataset")
+  op.setAttr("f", f)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(otherArguments)
+  let _ = op.addInput(cycleLength)
+  let _ = op.addInput(blockLength)
+  return op.execute(Int(1))
+}
+
+/// Computes the reciprocal of x element-wise.
+///
+/// I.e., \\(y = 1 / x\\).
+@inlinable @inline(__always)
+public static func inv<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Inv")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient for the inverse of `x` wrt its input.
+///
+/// Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy`
+/// is the corresponding input gradient.
+@inlinable @inline(__always)
+public static func invGrad<T: FloatingPoint & TensorFlowScalar>(
+  _ y: Tensor<T>,
+  dy: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("InvGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(y)
+  let _ = op.addInput(dy)
+  return op.execute(Int(1))
+}
+
+/// Flips all bits elementwise.
+///
+/// The result will have exactly those bits set, that are not set in `x`. The
+/// computation is performed on the underlying representation of x.
+@inlinable @inline(__always)
+public static func invert<T: BinaryInteger & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Invert")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the inverse permutation of a tensor.
+///
+/// This operation computes the inverse of an index permutation. It takes a 1-D
+/// integer tensor `x`, which represents the indices of a zero-based array, and
+/// swaps each value with its index position. In other words, for an output tensor
+/// `y` and an input tensor `x`, this operation computes the following:
+///
+/// `y[x[i]] = i for i in [0, 1, ..., len(x) - 1]`
+///
+/// The values must include 0. There can be no duplicate values or negative values.
+///
+/// For example:
+///
+/// ```
+/// # tensor `x` is [3, 4, 0, 2, 1]
+/// invert_permutation(x) ==> [2, 4, 3, 0, 1]
+/// ```
+///
+/// - Parameter x: 1-D.
+///
+/// - Output y: 1-D.
+@inlinable @inline(__always)
+public static func invertPermutation<T: BinaryInteger & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("InvertPermutation")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Checks whether a tree ensemble has been initialized.
+///
+/// - Parameter tree_ensemble_handle: Handle to the tree ensemble resouce.
+///
+/// - Output is_initialized: output boolean on whether it is initialized or not.
+@inlinable @inline(__always)
+public static func isBoostedTreesEnsembleInitialized(
+  treeEnsembleHandle: ResourceHandle
+) -> Tensor<Bool> {
+  let op = TFE_Op("IsBoostedTreesEnsembleInitialized")
+  let _ = op.addInput(treeEnsembleHandle)
+  return op.execute(Int(1))
+}
+
+/// Checks whether a quantile stream has been initialized.
+///
+/// An Op that checks if quantile stream resource is initialized.
+///
+/// - Parameter quantile_stream_resource_handle: resource; The reference to quantile stream resource handle.
+///
+/// - Output is_initialized: bool; True if the resource is initialized, False otherwise.
+@inlinable @inline(__always)
+public static func isBoostedTreesQuantileStreamResourceInitialized(
+  quantileStreamResourceHandle: ResourceHandle
+) -> Tensor<Bool> {
+  let op = TFE_Op("IsBoostedTreesQuantileStreamResourceInitialized")
+  let _ = op.addInput(quantileStreamResourceHandle)
+  return op.execute(Int(1))
+}
+
+/// Returns which elements of x are finite.
+///
+/// @compatibility(numpy)
+/// Equivalent to np.isfinite
+/// @end_compatibility
+@inlinable @inline(__always)
+public static func isFinite<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<Bool> {
+  let op = TFE_Op("IsFinite")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns which elements of x are Inf.
+///
+/// @compatibility(numpy)
+/// Equivalent to np.isinf
+/// @end_compatibility
+@inlinable @inline(__always)
+public static func isInf<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<Bool> {
+  let op = TFE_Op("IsInf")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns which elements of x are NaN.
+///
+/// @compatibility(numpy)
+/// Equivalent to np.isnan
+/// @end_compatibility
+@inlinable @inline(__always)
+public static func isNan<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<Bool> {
+  let op = TFE_Op("IsNan")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// A container for an iterator resource.
+///
+/// - Output handle: A handle to the iterator that can be passed to a "MakeIterator"
+///   or "IteratorGetNext" op.
+@inlinable @inline(__always)
+public static func iterator(
+  sharedName: String,
+  container: String,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let op = TFE_Op("Iterator")
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("container", container)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  return op.execute(Int(1))
+}
+
+/// Converts the given string representing a handle to an iterator to a resource.
+///
+/// - Parameter string_handle: A string representation of the given handle.
+///
+/// - Attrs:
+///   - output_types: If specified, defines the type of each tuple component in an
+///     element produced by the resulting iterator.
+///   - output_shapes: If specified, defines the shape of each tuple component in an
+///     element produced by the resulting iterator.
+///
+/// - Output resource_handle: A handle to an iterator resource.
+@inlinable @inline(__always)
+public static func iteratorFromStringHandle(
+  stringHandle: StringTensor,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let op = TFE_Op("IteratorFromStringHandle")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(stringHandle)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func iteratorFromStringHandleV2(
+  stringHandle: StringTensor,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let op = TFE_Op("IteratorFromStringHandleV2")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(stringHandle)
+  return op.execute(Int(1))
+}
+
+/// Gets the next output from the given iterator .
+@inlinable @inline(__always)
+public static func iteratorGetNext<OutputTypes: TensorGroup>(
+  iterator: ResourceHandle,
+  outputShapes: [TensorShape?]
+) -> OutputTypes {
+  let op = TFE_Op("IteratorGetNext")
+  op.setAttr("output_types", OutputTypes._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(iterator)
+  return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Gets the next output from the given iterator as an Optional variant.
+@inlinable @inline(__always)
+public static func iteratorGetNextAsOptional(
+  iterator: ResourceHandle,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("IteratorGetNextAsOptional")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(iterator)
+  return op.execute(Int(1))
+}
+
+/// Gets the next output from the given iterator.
+///
+/// This operation is a synchronous version IteratorGetNext. It should only be used
+/// in situations where the iterator does not block the calling thread, or where
+/// the calling thread is not a member of the thread pool used to execute parallel
+/// operations (e.g. in eager mode).
+@inlinable @inline(__always)
+public static func iteratorGetNextSync<OutputTypes: TensorGroup>(
+  iterator: ResourceHandle,
+  outputShapes: [TensorShape?]
+) -> OutputTypes {
+  let op = TFE_Op("IteratorGetNextSync")
+  op.setAttr("output_types", OutputTypes._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(iterator)
+  return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Converts the given `resource_handle` representing an iterator to a string.
+///
+/// - Parameter resource_handle: A handle to an iterator resource.
+///
+/// - Output string_handle: A string representation of the given handle.
+@inlinable @inline(__always)
+public static func iteratorToStringHandle(
+  resourceHandle: ResourceHandle
+) -> StringTensor {
+  let op = TFE_Op("IteratorToStringHandle")
+  let _ = op.addInput(resourceHandle)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func iteratorV2(
+  sharedName: String,
+  container: String,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let op = TFE_Op("IteratorV2")
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("container", container)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  return op.execute(Int(1))
+}
+
+/// Returns the index of a data point that should be added to the seed set.
+///
+/// Entries in distances are assumed to be squared distances of candidate points to
+/// the already sampled centers in the seed set. The op constructs one Markov chain
+/// of the k-MC^2 algorithm and returns the index of one candidate point to be added
+/// as an additional cluster center.
+///
+/// - Parameters:
+///   - distances: Vector with squared distances to the closest previously sampled cluster center
+///     for each candidate point.
+///   - seed: Scalar. Seed for initializing the random number generator.
+///
+/// - Output index: Scalar with the index of the sampled point.
+@inlinable @inline(__always)
+public static func kMC2ChainInitialization(
+  distances: Tensor<Float>,
+  seed: Tensor<Int64>
+) -> Tensor<Int64> {
+  let op = TFE_Op("KMC2ChainInitialization")
+  let _ = op.addInput(distances)
+  let _ = op.addInput(seed)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func kernelLabel(
+) -> StringTensor {
+  let op = TFE_Op("KernelLabel")
+  
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func kernelLabelRequired(
+  _ input: Tensor<Int32>
+) -> StringTensor {
+  let op = TFE_Op("KernelLabelRequired")
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Selects num_to_sample rows of input using the KMeans++ criterion.
+///
+/// Rows of points are assumed to be input points. One row is selected at random.
+/// Subsequent rows are sampled with probability proportional to the squared L2
+/// distance from the nearest row selected thus far till num_to_sample rows have
+/// been sampled.
+///
+/// - Parameters:
+///   - points: Matrix of shape (n, d). Rows are assumed to be input points.
+///   - num_to_sample: Scalar. The number of rows to sample. This value must not be larger than n.
+///   - seed: Scalar. Seed for initializing the random number generator.
+///   - num_retries_per_sample: Scalar. For each row that is sampled, this parameter
+///     specifies the number of additional points to draw from the current
+///     distribution before selecting the best. If a negative value is specified, a
+///     heuristic is used to sample O(log(num_to_sample)) additional points.
+///
+/// - Output samples: Matrix of shape (num_to_sample, d). The sampled rows.
+@inlinable @inline(__always)
+public static func kmeansPlusPlusInitialization(
+  points: Tensor<Float>,
+  numToSample: Tensor<Int64>,
+  seed: Tensor<Int64>,
+  numRetriesPerSample: Tensor<Int64>
+) -> Tensor<Float> {
+  let op = TFE_Op("KmeansPlusPlusInitialization")
+  let _ = op.addInput(points)
+  let _ = op.addInput(numToSample)
+  let _ = op.addInput(seed)
+  let _ = op.addInput(numRetriesPerSample)
+  return op.execute(Int(1))
+}
+
+/// L2 Loss.
+///
+/// Computes half the L2 norm of a tensor without the `sqrt`:
+///
+///     output = sum(t ** 2) / 2
+///
+/// - Parameter t: Typically 2-D, but may have any dimensions.
+///
+/// - Output output: 0-D.
+@inlinable @inline(__always)
+public static func l2Loss<T: FloatingPoint & TensorFlowScalar>(
+  t: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("L2Loss")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(t)
+  return op.execute(Int(1))
+}
+
+/// Local Response Normalization.
+///
+/// The 4-D `input` tensor is treated as a 3-D array of 1-D vectors (along the last
+/// dimension), and each vector is normalized independently.  Within a given vector,
+/// each component is divided by the weighted, squared sum of inputs within
+/// `depth_radius`.  In detail,
+///
+///     sqr_sum[a, b, c, d] =
+///         sum(input[a, b, c, d - depth_radius : d + depth_radius + 1] ** 2)
+///     output = input / (bias + alpha * sqr_sum) ** beta
+///
+/// For details, see [Krizhevsky et al., ImageNet classification with deep
+/// convolutional neural networks (NIPS 2012)](http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks).
+///
+/// - Parameter input: 4-D.
+///
+/// - Attrs:
+///   - depth_radius: 0-D.  Half-width of the 1-D normalization window.
+///   - bias: An offset (usually positive to avoid dividing by 0).
+///   - alpha: A scale factor, usually positive.
+///   - beta: An exponent.
+@inlinable @inline(__always)
+public static func lRN<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  depthRadius: Int64 = 5,
+  bias: Double = 1,
+  alpha: Double = 1,
+  beta: Double = 0.5
+) -> Tensor<T> {
+  let op = TFE_Op("LRN")
+  op.setAttr("depth_radius", depthRadius)
+  op.setAttr("bias", bias)
+  op.setAttr("alpha", alpha)
+  op.setAttr("beta", beta)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Gradients for Local Response Normalization.
+///
+/// - Parameters:
+///   - input_grads: 4-D with shape `[batch, height, width, channels]`.
+///   - input_image: 4-D with shape `[batch, height, width, channels]`.
+///   - output_image: 4-D with shape `[batch, height, width, channels]`.
+///
+/// - Attrs:
+///   - depth_radius: A depth radius.
+///   - bias: An offset (usually > 0 to avoid dividing by 0).
+///   - alpha: A scale factor, usually positive.
+///   - beta: An exponent.
+///
+/// - Output output: The gradients for LRN.
+@inlinable @inline(__always)
+public static func lRNGrad<T: FloatingPoint & TensorFlowScalar>(
+  inputGrads: Tensor<T>,
+  inputImage: Tensor<T>,
+  outputImage: Tensor<T>,
+  depthRadius: Int64 = 5,
+  bias: Double = 1,
+  alpha: Double = 1,
+  beta: Double = 0.5
+) -> Tensor<T> {
+  let op = TFE_Op("LRNGrad")
+  op.setAttr("depth_radius", depthRadius)
+  op.setAttr("bias", bias)
+  op.setAttr("alpha", alpha)
+  op.setAttr("beta", beta)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(inputGrads)
+  let _ = op.addInput(inputImage)
+  let _ = op.addInput(outputImage)
+  return op.execute(Int(1))
+}
+
+/// Computes the LSTM cell forward propagation for 1 time step.
+///
+/// This implementation uses 1 weight matrix and 1 bias vector, and there's an
+/// optional peephole connection.
+///
+/// This kernel op implements the following mathematical equations:
+///
+/// ```python
+/// xh = [x, h_prev]
+/// [i, f, ci, o] = xh * w + b
+/// f = f + forget_bias
+///
+/// if not use_peephole:
+///   wci = wcf = wco = 0
+///
+/// i = sigmoid(cs_prev * wci + i)
+/// f = sigmoid(cs_prev * wcf + f)
+/// ci = tanh(ci)
+///
+/// cs = ci .* i + cs_prev .* f
+/// cs = clip(cs, cell_clip)
+///
+/// o = sigmoid(cs * wco + o)
+/// co = tanh(cs)
+/// h = co .* o
+/// ```
+///
+/// - Parameters:
+///   - x: The input to the LSTM cell, shape (batch_size, num_inputs).
+///   - cs_prev: Value of the cell state at previous time step.
+///   - h_prev: Output of the previous cell at previous time step.
+///   - w: The weight matrix.
+///   - wci: The weight matrix for input gate peephole connection.
+///   - wcf: The weight matrix for forget gate peephole connection.
+///   - wco: The weight matrix for output gate peephole connection.
+///   - b: The bias vector.
+///
+/// - Attrs:
+///   - forget_bias: The forget gate bias.
+///   - cell_clip: Value to clip the 'cs' value to.
+///   - use_peephole: Whether to use peephole weights.
+///
+/// - Outputs:
+///   - i: The input gate.
+///   - cs: The cell state before the tanh.
+///   - f: The forget gate.
+///   - o: The output gate.
+///   - ci: The cell input.
+///   - co: The cell after the tanh.
+///   - h: The output h vector.
+@inlinable @inline(__always)
+public static func lSTMBlockCell<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  csPrev: Tensor<T>,
+  hPrev: Tensor<T>,
+  w: Tensor<T>,
+  wci: Tensor<T>,
+  wcf: Tensor<T>,
+  wco: Tensor<T>,
+  _ b: Tensor<T>,
+  forgetBias: Double = 1,
+  cellClip: Double = 3,
+  usePeephole: Bool = false
+) -> (i: Tensor<T>, cs: Tensor<T>, f: Tensor<T>, o: Tensor<T>, ci: Tensor<T>, co: Tensor<T>, h: Tensor<T>) {
+  let op = TFE_Op("LSTMBlockCell")
+  op.setAttr("forget_bias", forgetBias)
+  op.setAttr("cell_clip", cellClip)
+  op.setAttr("use_peephole", usePeephole)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(csPrev)
+  let _ = op.addInput(hPrev)
+  let _ = op.addInput(w)
+  let _ = op.addInput(wci)
+  let _ = op.addInput(wcf)
+  let _ = op.addInput(wco)
+  let _ = op.addInput(b)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Computes the LSTM cell backward propagation for 1 timestep.
+///
+/// This implementation is to be used in conjunction of LSTMBlockCell.
+///
+/// - Parameters:
+///   - x: The input to the LSTM cell, shape (batch_size, num_inputs).
+///   - cs_prev: The previous cell state.
+///   - h_prev: The previous h state.
+///   - w: The weight matrix.
+///   - wci: The weight matrix for input gate peephole connection.
+///   - wcf: The weight matrix for forget gate peephole connection.
+///   - wco: The weight matrix for output gate peephole connection.
+///   - b: The bias vector.
+///   - i: The input gate.
+///   - cs: The cell state before the tanh.
+///   - f: The forget gate.
+///   - o: The output gate.
+///   - ci: The cell input.
+///   - co: The cell after the tanh.
+///   - cs_grad: The current gradient of cs.
+///   - h_grad: The gradient of h vector.
+///
+/// - Attr use_peephole: Whether the cell uses peephole connections.
+///
+/// - Outputs:
+///   - cs_prev_grad: The gradient of cs to be back-propped.
+///   - dicfo: The derivative wrt to [i, cs, f, o].
+///   - wci_grad: The gradient for wci to be back-propped.
+///   - wcf_grad: The gradient for wcf to be back-propped.
+///   - wco_grad: The gradient for wco to be back-propped.
+@inlinable @inline(__always)
+public static func lSTMBlockCellGrad<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  csPrev: Tensor<T>,
+  hPrev: Tensor<T>,
+  w: Tensor<T>,
+  wci: Tensor<T>,
+  wcf: Tensor<T>,
+  wco: Tensor<T>,
+  _ b: Tensor<T>,
+  i: Tensor<T>,
+  cs: Tensor<T>,
+  f: Tensor<T>,
+  o: Tensor<T>,
+  ci: Tensor<T>,
+  co: Tensor<T>,
+  csGrad: Tensor<T>,
+  hGrad: Tensor<T>,
+  usePeephole: Bool
+) -> (csPrevGrad: Tensor<T>, dicfo: Tensor<T>, wciGrad: Tensor<T>, wcfGrad: Tensor<T>, wcoGrad: Tensor<T>) {
+  let op = TFE_Op("LSTMBlockCellGrad")
+  op.setAttr("use_peephole", usePeephole)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(csPrev)
+  let _ = op.addInput(hPrev)
+  let _ = op.addInput(w)
+  let _ = op.addInput(wci)
+  let _ = op.addInput(wcf)
+  let _ = op.addInput(wco)
+  let _ = op.addInput(b)
+  let _ = op.addInput(i)
+  let _ = op.addInput(cs)
+  let _ = op.addInput(f)
+  let _ = op.addInput(o)
+  let _ = op.addInput(ci)
+  let _ = op.addInput(co)
+  let _ = op.addInput(csGrad)
+  let _ = op.addInput(hGrad)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Computes rectified linear: `max(features, features * alpha)`.
+@inlinable @inline(__always)
+public static func leakyRelu<T: FloatingPoint & TensorFlowScalar>(
+  features: Tensor<T>,
+  alpha: Double = 0.2
+) -> Tensor<T> {
+  let op = TFE_Op("LeakyRelu")
+  op.setAttr("alpha", alpha)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(features)
+  return op.execute(Int(1))
+}
+
+/// Computes rectified linear gradients for a LeakyRelu operation.
+///
+/// - Parameters:
+///   - gradients: The backpropagated gradients to the corresponding LeakyRelu operation.
+///   - features: The features passed as input to the corresponding LeakyRelu operation,
+///     OR the outputs of that operation (both work equivalently).
+///
+/// - Output backprops: `gradients * (features > 0) + alpha * gradients * (featurs <= 0)`.
+@inlinable @inline(__always)
+public static func leakyReluGrad<T: FloatingPoint & TensorFlowScalar>(
+  gradients: Tensor<T>,
+  features: Tensor<T>,
+  alpha: Double = 0.2
+) -> Tensor<T> {
+  let op = TFE_Op("LeakyReluGrad")
+  op.setAttr("alpha", alpha)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(gradients)
+  let _ = op.addInput(features)
+  return op.execute(Int(1))
+}
+
+/// Generates labels for candidate sampling with a learned unigram distribution.
+///
+/// See explanations of candidate sampling and the data formats at
+/// go/candidate-sampling.
+///
+/// For each batch, this op picks a single set of sampled candidate labels.
+///
+/// The advantages of sampling candidates per-batch are simplicity and the
+/// possibility of efficient dense matrix multiplication. The disadvantage is that
+/// the sampled candidates must be chosen independently of the context and of the
+/// true labels.
+///
+/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
+///   IDs of the num_true target_classes in the corresponding original label.
+///
+/// - Attrs:
+///   - num_true: Number of true labels per context.
+///   - num_sampled: Number of candidates to randomly sample.
+///   - unique: If unique is true, we sample with rejection, so that all sampled
+///     candidates in a batch are unique. This requires some approximation to
+///     estimate the post-rejection sampling probabilities.
+///   - range_max: The sampler will sample integers from the interval [0, range_max).
+///   - seed: If either seed or seed2 are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///   - sampled_candidates: A vector of length num_sampled, in which each element is
+///     the ID of a sampled candidate.
+///   - true_expected_count: A batch_size * num_true matrix, representing
+///     the number of times each candidate is expected to occur in a batch
+///     of sampled candidates. If unique=true, then this is a probability.
+///   - sampled_expected_count: A vector of length num_sampled, for each sampled
+///     candidate representing the number of times the candidate is expected
+///     to occur in a batch of sampled candidates.  If unique=true, then this is a
+///     probability.
+@inlinable @inline(__always)
+public static func learnedUnigramCandidateSampler(
+  trueClasses: Tensor<Int64>,
+  numTrue: Int64,
+  numSampled: Int64,
+  unique: Bool,
+  rangeMax: Int64,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
+  let op = TFE_Op("LearnedUnigramCandidateSampler")
+  op.setAttr("num_true", numTrue)
+  op.setAttr("num_sampled", numSampled)
+  op.setAttr("unique", unique)
+  op.setAttr("range_max", rangeMax)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(trueClasses)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Elementwise computes the bitwise left-shift of `x` and `y`.
+///
+/// If `y` is negative, or greater than or equal to the width of `x` in bits the
+/// result is implementation defined.
+@inlinable @inline(__always)
+public static func leftShift<T: BinaryInteger & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("LeftShift")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x < y) element-wise.
+///
+/// *NOTE*: `Less` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func less<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<Bool> {
+  let op = TFE_Op("Less")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x <= y) element-wise.
+///
+/// *NOTE*: `LessEqual` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func lessEqual<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<Bool> {
+  let op = TFE_Op("LessEqual")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Computes the log of the absolute value of `Gamma(x)` element-wise.
+@inlinable @inline(__always)
+public static func lgamma<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Lgamma")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Generates values in an interval.
+///
+/// A sequence of `num` evenly-spaced values are generated beginning at `start`.
+/// If `num > 1`, the values in the sequence increase by `stop - start / num - 1`,
+/// so that the last one is exactly `stop`.
+///
+/// For example:
+///
+/// ```
+/// tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0  11.0  12.0]
+/// ```
+///
+/// - Parameters:
+///   - start: 0-D tensor. First entry in the range.
+///   - stop: 0-D tensor. Last entry in the range.
+///   - num: 0-D tensor. Number of values to generate.
+///
+/// - Output output: 1-D. The generated values.
+@inlinable @inline(__always)
+public static func linSpace<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  start: Tensor<T>,
+  stop: Tensor<T>,
+  num: Tensor<Tidx>
+) -> Tensor<T> {
+  let op = TFE_Op("LinSpace")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(start)
+  let _ = op.addInput(stop)
+  let _ = op.addInput(num)
+  return op.execute(Int(1))
+}
+
+/// Computes the difference between two lists of numbers or strings.
+///
+/// Given a list `x` and a list `y`, this operation returns a list `out` that
+/// represents all values that are in `x` but not in `y`. The returned list `out`
+/// is sorted in the same order that the numbers appear in `x` (duplicates are
+/// preserved). This operation also returns a list `idx` that represents the
+/// position of each `out` element in `x`. In other words:
+///
+/// `out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]`
+///
+/// For example, given this input:
+///
+/// ```
+/// x = [1, 2, 3, 4, 5, 6]
+/// y = [1, 3, 5]
+/// ```
+///
+/// This operation would return:
+///
+/// ```
+/// out ==> [2, 4, 6]
+/// idx ==> [1, 3, 5]
+/// ```
+///
+/// - Parameters:
+///   - x: 1-D. Values to keep.
+///   - y: 1-D. Values to remove.
+///
+/// - Outputs:
+///   - out: 1-D. Values present in `x` but not in `y`.
+///   - idx: 1-D. Positions of `x` values preserved in `out`.
+@inlinable @inline(__always)
+public static func listDiff<
+    T: TensorFlowScalar,
+    OutIdx: BinaryInteger & TensorFlowScalar
+>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> (out: Tensor<T>, idx: Tensor<OutIdx>) {
+  let op = TFE_Op("ListDiff")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_idx", OutIdx.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func listInput<T: TensorFlowScalar>(
+  _ a: [Tensor<T>]
+) {
+  let op = TFE_Op("ListInput")
+  op.setAttr("N", a.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInputList(a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func listOutput<T: TensorGroup>(
+) -> T {
+  let op = TFE_Op("ListOutput")
+  op.setAttr("T", T._typeList)
+  return op.execute(Int(T._typeList.count))
+}
+
+/// Loads a 2-D (matrix) `Tensor` with name `old_tensor_name` from the checkpoint
+///
+/// at `ckpt_path` and potentially reorders its rows and columns using the
+/// specified remappings.
+///
+/// Most users should use one of the wrapper initializers (such as
+/// `tf.contrib.framework.load_and_remap_matrix_initializer`) instead of this
+/// function directly.
+///
+/// The remappings are 1-D tensors with the following properties:
+///
+/// * `row_remapping` must have exactly `num_rows` entries. Row `i` of the output
+///   matrix will be initialized from the row corresponding to index
+///   `row_remapping[i]` in the old `Tensor` from the checkpoint.
+/// * `col_remapping` must have either 0 entries (indicating that no column
+///   reordering is needed) or `num_cols` entries. If specified, column `j` of the
+///   output matrix will be initialized from the column corresponding to index
+///   `col_remapping[j]` in the old `Tensor` from the checkpoint.
+/// * A value of -1 in either of the remappings signifies a "missing" entry. In that
+///   case, values from the `initializing_values` tensor will be used to fill that
+///   missing row or column. If `row_remapping` has `r` missing entries and
+///   `col_remapping` has `c` missing entries, then the following condition must be
+///   true:
+///
+/// `(r * num_cols) + (c * num_rows) - (r * c) == len(initializing_values)`
+///
+/// The remapping tensors can be generated using the GenerateVocabRemapping op.
+///
+/// As an example, with row_remapping = [1, 0, -1], col_remapping = [0, 2, -1],
+/// initializing_values = [0.5, -0.5, 0.25, -0.25, 42], and w(i, j) representing
+/// the value from row i, column j of the old tensor in the checkpoint, the output
+/// matrix will look like the following:
+///
+/// [[w(1, 0),  w(1, 2),  0.5],
+///  [w(0, 0),  w(0, 2), -0.5],
+///  [0.25,    -0.25,      42]]
+///
+/// - Parameters:
+///   - ckpt_path: Path to the TensorFlow checkpoint (version 2, `TensorBundle`) from
+///     which the old matrix `Tensor` will be loaded.
+///   - old_tensor_name: Name of the 2-D `Tensor` to load from checkpoint.
+///   - row_remapping: An int `Tensor` of row remappings (generally created by
+///     `generate_vocab_remapping`).  Even if no row remapping is needed, this must
+///     still be an index-valued Tensor (e.g. [0, 1, 2, ...]), or a shifted
+///     index-valued `Tensor` (e.g. [8, 9, 10, ...], for partitioned `Variables`).
+///   - col_remapping: An int `Tensor` of column remappings (generally created by
+///     `generate_vocab_remapping`).  May be a size-0 `Tensor` if only row remapping
+///     is to be done (e.g. column ordering is the same).
+///   - initializing_values: A float `Tensor` containing  values to fill in for cells
+///     in the output matrix that are not loaded from the checkpoint. Length must be
+///     exactly the same as the number of missing / new cells.
+///
+/// - Attrs:
+///   - num_rows: Number of rows (length of the 1st dimension) in the output matrix.
+///   - num_cols: Number of columns (length of the 2nd dimension) in the output matrix.
+///   - max_rows_in_memory: The maximum number of rows to load from the checkpoint at
+///     once. If less than or equal to 0, the entire matrix will be loaded into
+///     memory. Setting this arg trades increased disk reads for lower memory usage.
+///
+/// - Output output_matrix: Output matrix containing existing values loaded from the
+///   checkpoint, and with any missing values filled in from initializing_values.
+@inlinable @inline(__always)
+public static func loadAndRemapMatrix(
+  ckptPath: StringTensor,
+  oldTensorName: StringTensor,
+  rowRemapping: Tensor<Int64>,
+  colRemapping: Tensor<Int64>,
+  initializingValues: Tensor<Float>,
+  numRows: Int64,
+  numCols: Int64,
+  maxRowsInMemory: Int64 = -1
+) -> Tensor<Float> {
+  let op = TFE_Op("LoadAndRemapMatrix")
+  op.setAttr("num_rows", numRows)
+  op.setAttr("num_cols", numCols)
+  op.setAttr("max_rows_in_memory", maxRowsInMemory)
+  let _ = op.addInput(ckptPath)
+  let _ = op.addInput(oldTensorName)
+  let _ = op.addInput(rowRemapping)
+  let _ = op.addInput(colRemapping)
+  let _ = op.addInput(initializingValues)
+  return op.execute(Int(1))
+}
+
+/// Load ADAM embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the ADAM optimization algorithm.
+///   - momenta: Value of momenta used in the ADAM optimization algorithm.
+///   - velocities: Value of velocities used in the ADAM optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingADAMParameters(
+  parameters: Tensor<Float>,
+  momenta: Tensor<Float>,
+  velocities: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingADAMParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(momenta)
+  let _ = op.addInput(velocities)
+  op.execute()
+}
+
+/// Load ADAM embedding parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the ADAM optimization algorithm.
+///   - momenta: Value of momenta used in the ADAM optimization algorithm.
+///   - velocities: Value of velocities used in the ADAM optimization algorithm.
+///   - gradient_accumulators: Value of gradient_accumulators used in the ADAM optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingADAMParametersGradAccumDebug(
+  parameters: Tensor<Float>,
+  momenta: Tensor<Float>,
+  velocities: Tensor<Float>,
+  gradientAccumulators: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingADAMParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(momenta)
+  let _ = op.addInput(velocities)
+  let _ = op.addInput(gradientAccumulators)
+  op.execute()
+}
+
+/// Load Adadelta embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the Adadelta optimization algorithm.
+///   - accumulators: Value of accumulators used in the Adadelta optimization algorithm.
+///   - updates: Value of updates used in the Adadelta optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingAdadeltaParameters(
+  parameters: Tensor<Float>,
+  accumulators: Tensor<Float>,
+  updates: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingAdadeltaParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(accumulators)
+  let _ = op.addInput(updates)
+  op.execute()
+}
+
+/// Load Adadelta parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the Adadelta optimization algorithm.
+///   - accumulators: Value of accumulators used in the Adadelta optimization algorithm.
+///   - updates: Value of updates used in the Adadelta optimization algorithm.
+///   - gradient_accumulators: Value of gradient_accumulators used in the Adadelta optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingAdadeltaParametersGradAccumDebug(
+  parameters: Tensor<Float>,
+  accumulators: Tensor<Float>,
+  updates: Tensor<Float>,
+  gradientAccumulators: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingAdadeltaParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(accumulators)
+  let _ = op.addInput(updates)
+  let _ = op.addInput(gradientAccumulators)
+  op.execute()
+}
+
+/// Load Adagrad embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the Adagrad optimization algorithm.
+///   - accumulators: Value of accumulators used in the Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingAdagradParameters(
+  parameters: Tensor<Float>,
+  accumulators: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingAdagradParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(accumulators)
+  op.execute()
+}
+
+/// Load Adagrad embedding parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the Adagrad optimization algorithm.
+///   - accumulators: Value of accumulators used in the Adagrad optimization algorithm.
+///   - gradient_accumulators: Value of gradient_accumulators used in the Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingAdagradParametersGradAccumDebug(
+  parameters: Tensor<Float>,
+  accumulators: Tensor<Float>,
+  gradientAccumulators: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingAdagradParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(accumulators)
+  let _ = op.addInput(gradientAccumulators)
+  op.execute()
+}
+
+/// Load centered RMSProp embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the centered RMSProp optimization algorithm.
+///   - ms: Value of ms used in the centered RMSProp optimization algorithm.
+///   - mom: Value of mom used in the centered RMSProp optimization algorithm.
+///   - mg: Value of mg used in the centered RMSProp optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingCenteredRMSPropParameters(
+  parameters: Tensor<Float>,
+  ms: Tensor<Float>,
+  mom: Tensor<Float>,
+  mg: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingCenteredRMSPropParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(ms)
+  let _ = op.addInput(mom)
+  let _ = op.addInput(mg)
+  op.execute()
+}
+
+/// Load FTRL embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the FTRL optimization algorithm.
+///   - accumulators: Value of accumulators used in the FTRL optimization algorithm.
+///   - linears: Value of linears used in the FTRL optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingFTRLParameters(
+  parameters: Tensor<Float>,
+  accumulators: Tensor<Float>,
+  linears: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingFTRLParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(accumulators)
+  let _ = op.addInput(linears)
+  op.execute()
+}
+
+/// Load FTRL embedding parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the FTRL optimization algorithm.
+///   - accumulators: Value of accumulators used in the FTRL optimization algorithm.
+///   - linears: Value of linears used in the FTRL optimization algorithm.
+///   - gradient_accumulators: Value of gradient_accumulators used in the FTRL optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingFTRLParametersGradAccumDebug(
+  parameters: Tensor<Float>,
+  accumulators: Tensor<Float>,
+  linears: Tensor<Float>,
+  gradientAccumulators: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingFTRLParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(accumulators)
+  let _ = op.addInput(linears)
+  let _ = op.addInput(gradientAccumulators)
+  op.execute()
+}
+
+/// Load MDL Adagrad Light embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the MDL Adagrad Light optimization algorithm.
+///   - accumulators: Value of accumulators used in the MDL Adagrad Light optimization algorithm.
+///   - weights: Value of weights used in the MDL Adagrad Light optimization algorithm.
+///   - benefits: Value of benefits used in the MDL Adagrad Light optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingMDLAdagradLightParameters(
+  parameters: Tensor<Float>,
+  accumulators: Tensor<Float>,
+  weights: Tensor<Float>,
+  benefits: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingMDLAdagradLightParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(accumulators)
+  let _ = op.addInput(weights)
+  let _ = op.addInput(benefits)
+  op.execute()
+}
+
+/// Load Momentum embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the Momentum optimization algorithm.
+///   - momenta: Value of momenta used in the Momentum optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingMomentumParameters(
+  parameters: Tensor<Float>,
+  momenta: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingMomentumParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(momenta)
+  op.execute()
+}
+
+/// Load Momentum embedding parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the Momentum optimization algorithm.
+///   - momenta: Value of momenta used in the Momentum optimization algorithm.
+///   - gradient_accumulators: Value of gradient_accumulators used in the Momentum optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingMomentumParametersGradAccumDebug(
+  parameters: Tensor<Float>,
+  momenta: Tensor<Float>,
+  gradientAccumulators: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingMomentumParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(momenta)
+  let _ = op.addInput(gradientAccumulators)
+  op.execute()
+}
+
+/// Load proximal Adagrad embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the proximal Adagrad optimization algorithm.
+///   - accumulators: Value of accumulators used in the proximal Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingProximalAdagradParameters(
+  parameters: Tensor<Float>,
+  accumulators: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingProximalAdagradParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(accumulators)
+  op.execute()
+}
+
+/// Load proximal Adagrad embedding parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the proximal Adagrad optimization algorithm.
+///   - accumulators: Value of accumulators used in the proximal Adagrad optimization algorithm.
+///   - gradient_accumulators: Value of gradient_accumulators used in the proximal Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingProximalAdagradParametersGradAccumDebug(
+  parameters: Tensor<Float>,
+  accumulators: Tensor<Float>,
+  gradientAccumulators: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(accumulators)
+  let _ = op.addInput(gradientAccumulators)
+  op.execute()
+}
+
+/// Load RMSProp embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the RMSProp optimization algorithm.
+///   - ms: Value of ms used in the RMSProp optimization algorithm.
+///   - mom: Value of mom used in the RMSProp optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingRMSPropParameters(
+  parameters: Tensor<Float>,
+  ms: Tensor<Float>,
+  mom: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingRMSPropParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(ms)
+  let _ = op.addInput(mom)
+  op.execute()
+}
+
+/// Load RMSProp embedding parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///   - parameters: Value of parameters used in the RMSProp optimization algorithm.
+///   - ms: Value of ms used in the RMSProp optimization algorithm.
+///   - mom: Value of mom used in the RMSProp optimization algorithm.
+///   - gradient_accumulators: Value of gradient_accumulators used in the RMSProp optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingRMSPropParametersGradAccumDebug(
+  parameters: Tensor<Float>,
+  ms: Tensor<Float>,
+  mom: Tensor<Float>,
+  gradientAccumulators: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingRMSPropParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  let _ = op.addInput(ms)
+  let _ = op.addInput(mom)
+  let _ = op.addInput(gradientAccumulators)
+  op.execute()
+}
+
+/// Load SGD embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameter parameters: Value of parameters used in the stochastic gradient descent optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingStochasticGradientDescentParameters(
+  parameters: Tensor<Float>,
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) {
+  let op = TFE_Op("LoadTPUEmbeddingStochasticGradientDescentParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  let _ = op.addInput(parameters)
+  op.execute()
+}
+
+/// Computes natural logarithm of x element-wise.
+///
+/// I.e., \\(y = \log_e x\\).
+@inlinable @inline(__always)
+public static func log<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Log")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes natural logarithm of (1 + x) element-wise.
+///
+/// I.e., \\(y = \log_e (1 + x)\\).
+@inlinable @inline(__always)
+public static func log1p<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Log1p")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the sign and the log of the absolute value of the determinant of
+///
+/// one or more square matrices.
+///
+/// The input is a tensor of shape `[N, M, M]` whose inner-most 2 dimensions
+/// form square matrices. The outputs are two tensors containing the signs and
+/// absolute values of the log determinants for all N input submatrices
+/// `[..., :, :]` such that the determinant = sign*exp(log_abs_determinant).
+/// The log_abs_determinant is computed as det(P)*sum(log(diag(LU))) where LU
+/// is the LU decomposition of the input and P is the corresponding
+/// permutation matrix.
+///
+/// - Parameter input: Shape is `[N, M, M]`.
+///
+/// - Outputs:
+///   - sign: The signs of the log determinants of the inputs. Shape is `[N]`.
+///   - log_abs_determinant: The logs of the absolute values of the determinants
+///     of the N input matrices.  Shape is `[N]`.
+@inlinable @inline(__always)
+public static func logMatrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> (sign: Tensor<T>, logAbsDeterminant: Tensor<T>) {
+  let op = TFE_Op("LogMatrixDeterminant")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Computes log softmax activations.
+///
+/// For each batch `i` and class `j` we have
+///
+///     logsoftmax[i, j] = logits[i, j] - log(sum(exp(logits[i])))
+///
+/// - Parameter logits: 2-D with shape `[batch_size, num_classes]`.
+///
+/// - Output logsoftmax: Same shape as `logits`.
+@inlinable @inline(__always)
+public static func logSoftmax<T: FloatingPoint & TensorFlowScalar>(
+  logits: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("LogSoftmax")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(logits)
+  return op.execute(Int(1))
+}
+
+/// Generates labels for candidate sampling with a log-uniform distribution.
+///
+/// See explanations of candidate sampling and the data formats at
+/// go/candidate-sampling.
+///
+/// For each batch, this op picks a single set of sampled candidate labels.
+///
+/// The advantages of sampling candidates per-batch are simplicity and the
+/// possibility of efficient dense matrix multiplication. The disadvantage is that
+/// the sampled candidates must be chosen independently of the context and of the
+/// true labels.
+///
+/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
+///   IDs of the num_true target_classes in the corresponding original label.
+///
+/// - Attrs:
+///   - num_true: Number of true labels per context.
+///   - num_sampled: Number of candidates to randomly sample.
+///   - unique: If unique is true, we sample with rejection, so that all sampled
+///     candidates in a batch are unique. This requires some approximation to
+///     estimate the post-rejection sampling probabilities.
+///   - range_max: The sampler will sample integers from the interval [0, range_max).
+///   - seed: If either seed or seed2 are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///   - sampled_candidates: A vector of length num_sampled, in which each element is
+///     the ID of a sampled candidate.
+///   - true_expected_count: A batch_size * num_true matrix, representing
+///     the number of times each candidate is expected to occur in a batch
+///     of sampled candidates. If unique=true, then this is a probability.
+///   - sampled_expected_count: A vector of length num_sampled, for each sampled
+///     candidate representing the number of times the candidate is expected
+///     to occur in a batch of sampled candidates.  If unique=true, then this is a
+///     probability.
+@inlinable @inline(__always)
+public static func logUniformCandidateSampler(
+  trueClasses: Tensor<Int64>,
+  numTrue: Int64,
+  numSampled: Int64,
+  unique: Bool,
+  rangeMax: Int64,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
+  let op = TFE_Op("LogUniformCandidateSampler")
+  op.setAttr("num_true", numTrue)
+  op.setAttr("num_sampled", numSampled)
+  op.setAttr("unique", unique)
+  op.setAttr("range_max", rangeMax)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(trueClasses)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Returns the truth value of x AND y element-wise.
+///
+/// *NOTE*: `LogicalAnd` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func logicalAnd(
+  _ x: Tensor<Bool>,
+  _ y: Tensor<Bool>
+) -> Tensor<Bool> {
+  let op = TFE_Op("LogicalAnd")
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns the truth value of NOT x element-wise.
+@inlinable @inline(__always)
+public static func logicalNot(
+  _ x: Tensor<Bool>
+) -> Tensor<Bool> {
+  let op = TFE_Op("LogicalNot")
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns the truth value of x OR y element-wise.
+///
+/// *NOTE*: `LogicalOr` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func logicalOr(
+  _ x: Tensor<Bool>,
+  _ y: Tensor<Bool>
+) -> Tensor<Bool> {
+  let op = TFE_Op("LogicalOr")
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Outputs all keys and values in the table.
+///
+/// - Parameter table_handle: Handle to the table.
+///
+/// - Outputs:
+///   - keys: Vector of all keys present in the table.
+///   - values: Tensor of all values in the table. Indexed in parallel with `keys`.
+@inlinable @inline(__always)
+public static func lookupTableExportV2<
+    Tkeys: TensorFlowScalar,
+    Tvalues: TensorFlowScalar
+>(
+  tableHandle: ResourceHandle
+) -> (keys: Tensor<Tkeys>, values: Tensor<Tvalues>) {
+  let op = TFE_Op("LookupTableExportV2")
+  op.setAttr("Tkeys", Tkeys.tensorFlowDataType)
+  op.setAttr("Tvalues", Tvalues.tensorFlowDataType)
+  let _ = op.addInput(tableHandle)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Looks up keys in a table, outputs the corresponding values.
+///
+/// The tensor `keys` must of the same type as the keys of the table.
+/// The output `values` is of the type of the table values.
+///
+/// The scalar `default_value` is the value output for keys not present in the
+/// table. It must also be of the same type as the table values.
+///
+/// - Parameters:
+///   - table_handle: Handle to the table.
+///   - keys: Any shape.  Keys to look up.
+///
+/// - Output values: Same shape as `keys`.  Values found in the table, or `default_values`
+///   for missing keys.
+@inlinable @inline(__always)
+public static func lookupTableFindV2<
+    Tin: TensorFlowScalar,
+    Tout: TensorFlowScalar
+>(
+  tableHandle: ResourceHandle,
+  keys: Tensor<Tin>,
+  defaultValue: Tensor<Tout>
+) -> Tensor<Tout> {
+  let op = TFE_Op("LookupTableFindV2")
+  op.setAttr("Tin", Tin.tensorFlowDataType)
+  op.setAttr("Tout", Tout.tensorFlowDataType)
+  let _ = op.addInput(tableHandle)
+  let _ = op.addInput(keys)
+  let _ = op.addInput(defaultValue)
+  return op.execute(Int(1))
+}
+
+/// Replaces the contents of the table with the specified keys and values.
+///
+/// The tensor `keys` must be of the same type as the keys of the table.
+/// The tensor `values` must be of the type of the table values.
+///
+/// - Parameters:
+///   - table_handle: Handle to the table.
+///   - keys: Any shape.  Keys to look up.
+///   - values: Values to associate with keys.
+@inlinable @inline(__always)
+public static func lookupTableImportV2<
+    Tin: TensorFlowScalar,
+    Tout: TensorFlowScalar
+>(
+  tableHandle: ResourceHandle,
+  keys: Tensor<Tin>,
+  _ values: Tensor<Tout>
+) {
+  let op = TFE_Op("LookupTableImportV2")
+  op.setAttr("Tin", Tin.tensorFlowDataType)
+  op.setAttr("Tout", Tout.tensorFlowDataType)
+  let _ = op.addInput(tableHandle)
+  let _ = op.addInput(keys)
+  let _ = op.addInput(values)
+  op.execute()
+}
+
+/// Updates the table to associates keys with values.
+///
+/// The tensor `keys` must be of the same type as the keys of the table.
+/// The tensor `values` must be of the type of the table values.
+///
+/// - Parameters:
+///   - table_handle: Handle to the table.
+///   - keys: Any shape.  Keys to look up.
+///   - values: Values to associate with keys.
+@inlinable @inline(__always)
+public static func lookupTableInsertV2<
+    Tin: TensorFlowScalar,
+    Tout: TensorFlowScalar
+>(
+  tableHandle: ResourceHandle,
+  keys: Tensor<Tin>,
+  _ values: Tensor<Tout>
+) {
+  let op = TFE_Op("LookupTableInsertV2")
+  op.setAttr("Tin", Tin.tensorFlowDataType)
+  op.setAttr("Tout", Tout.tensorFlowDataType)
+  let _ = op.addInput(tableHandle)
+  let _ = op.addInput(keys)
+  let _ = op.addInput(values)
+  op.execute()
+}
+
+/// Removes keys and its associated values from a table.
+///
+/// The tensor `keys` must of the same type as the keys of the table. Keys not
+/// already in the table are silently ignored.
+///
+/// - Parameters:
+///   - table_handle: Handle to the table.
+///   - keys: Any shape.  Keys of the elements to remove.
+@inlinable @inline(__always)
+public static func lookupTableRemoveV2<Tin: TensorFlowScalar>(
+  tableHandle: ResourceHandle,
+  keys: Tensor<Tin>
+) {
+  let op = TFE_Op("LookupTableRemoveV2")
+  op.setAttr("Tin", Tin.tensorFlowDataType)
+  let _ = op.addInput(tableHandle)
+  let _ = op.addInput(keys)
+  op.execute()
+}
+
+/// Computes the number of elements in the given table.
+///
+/// - Parameter table_handle: Handle to the table.
+///
+/// - Output size: Scalar that contains number of elements in the table.
+@inlinable @inline(__always)
+public static func lookupTableSizeV2(
+  tableHandle: ResourceHandle
+) -> Tensor<Int64> {
+  let op = TFE_Op("LookupTableSizeV2")
+  let _ = op.addInput(tableHandle)
+  return op.execute(Int(1))
+}
+
+/// Forwards the input to the output.
+///
+/// This operator represents the loop termination condition used by the
+/// "pivot" switches of a loop.
+///
+/// - Parameter input: A boolean scalar, representing the branch predicate of the Switch op.
+///
+/// - Output output: The same tensor as `input`.
+@inlinable @inline(__always)
+public static func loopCond(
+  _ input: Tensor<Bool>
+) -> Tensor<Bool> {
+  let op = TFE_Op("LoopCond")
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Applies lower_bound(sorted_search_values, values) along each row.
+///
+/// Each set of rows with the same index in (sorted_inputs, values) is treated
+/// independently.  The resulting row is the equivalent of calling
+/// `np.searchsorted(sorted_inputs, values, side='left')`.
+///
+/// The result is not a global index to the entire 
+/// `Tensor`, but rather just the index in the last dimension.
+///
+/// A 2-D example:
+///   sorted_sequence = [[0, 3, 9, 9, 10],
+///                      [1, 2, 3, 4, 5]]
+///   values = [[2, 4, 9],
+///             [0, 2, 6]]
+///
+///   result = LowerBound(sorted_sequence, values)
+///
+///   result == [[1, 2, 2],
+///              [0, 1, 5]]
+///
+/// - Parameters:
+///   - sorted_inputs: 2-D Tensor where each row is ordered.
+///   - values: 2-D Tensor with the same numbers of rows as `sorted_search_values`. Contains
+///     the values that will be searched for in `sorted_search_values`.
+///
+/// - Output output: A `Tensor` with the same shape as `values`.  It contains the first scalar index
+///   into the last dimension where values can be inserted without changing the
+///   ordered property.
+@inlinable @inline(__always)
+public static func lowerBound<
+    T: TensorFlowScalar,
+    OutType: BinaryInteger & TensorFlowScalar
+>(
+  sortedInputs: Tensor<T>,
+  _ values: Tensor<T>
+) -> Tensor<OutType> {
+  let op = TFE_Op("LowerBound")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(sortedInputs)
+  let _ = op.addInput(values)
+  return op.execute(Int(1))
+}
+
+/// Computes the LU decomposition of one or more square matrices.
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices.
+///
+/// The input has to be invertible.
+///
+/// The output consists of two tensors LU and P containing the LU decomposition
+/// of all input submatrices `[..., :, :]`. LU encodes the lower triangular and
+/// upper triangular factors.
+///
+/// For each input submatrix of shape `[M, M]`, L is a lower triangular matrix of
+/// shape `[M, M]` with unit diagonal whose entries correspond to the strictly lower
+/// triangular part of LU. U is a upper triangular matrix of shape `[M, M]` whose
+/// entries correspond to the upper triangular part, including the diagonal, of LU.
+///
+/// P represents a permutation matrix encoded as a list of indices each between `0`
+/// and `M-1`, inclusive. If P_mat denotes the permutation matrix corresponding to
+/// P, then the L, U and P satisfies P_mat * input = L * U.
+///
+/// - Parameter input: A tensor of shape `[..., M, M]` whose inner-most 2 dimensions form matrices of
+///   size `[M, M]`.
+///
+/// - Outputs:
+///   - lu: A tensor of shape `[..., M, M]` whose strictly lower triangular part denotes the
+///     lower triangular factor `L` with unit diagonal, and whose upper triangular part
+///     denotes the upper triangular factor `U`.
+///   - p: Permutation of the rows encoded as a list of indices in `0..M-1`. Shape is
+///     `[..., M]`.
+///     @compatibility(scipy)
+///     Similar to `scipy.linalg.lu`, except the triangular factors `L` and `U` are
+///     packed into a single tensor, the permutation is applied to `input` instead of
+///     the right hand side and the permutation `P` is returned as a list of indices
+///     instead of a permutation matrix.
+///     @end_compatibility
+@inlinable @inline(__always)
+public static func lu<
+    T: FloatingPoint & TensorFlowScalar,
+    OutputIdxType: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>
+) -> (lu: Tensor<T>, p: Tensor<OutputIdxType>) {
+  let op = TFE_Op("Lu")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("output_idx_type", OutputIdxType.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Makes a new iterator from the given `dataset` and stores it in `iterator`.
+///
+/// This operation may be executed multiple times. Each execution will reset the
+/// iterator in `iterator` to the first element of `dataset`.
+@inlinable @inline(__always)
+public static func makeIterator(
+  dataset: VariantHandle,
+  iterator: ResourceHandle
+) {
+  let op = TFE_Op("MakeIterator")
+  let _ = op.addInput(dataset)
+  let _ = op.addInput(iterator)
+  op.execute()
+}
+
+/// Op removes all elements in the underlying container.
+@inlinable @inline(__always)
+public static func mapClear(
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  dtypes: [TensorDataType],
+  container: String,
+  sharedName: String
+) {
+  let op = TFE_Op("MapClear")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", dtypes)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.execute()
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+@inlinable @inline(__always)
+public static func mapDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  otherArguments: Targuments,
+  f: (FIn) -> FOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?],
+  useInterOpParallelism: Bool = true,
+  preserveCardinality: Bool = false
+) -> VariantHandle {
+  let op = TFE_Op("MapDataset")
+  op.setAttr("f", f)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("use_inter_op_parallelism", useInterOpParallelism)
+  op.setAttr("preserve_cardinality", preserveCardinality)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(otherArguments)
+  return op.execute(Int(1))
+}
+
+///   Maps a function on the list of tensors unpacked from arguments on dimension 0.
+///   The function given by `f` is assumed to be stateless, and is executed
+///   concurrently on all the slices; up to batch_size (i.e. the size of the 0th
+///   dimension of each argument) functions will be scheduled at once.
+///
+///   The `max_intra_op_parallelism` attr, which defaults to 1, can be used to
+///   limit the intra op parallelism. To limit inter-op parallelism, a user can
+///   set a private threadpool on the dataset using `tf.data.Options`'s
+///   `ThreadingOptions`.
+///
+///   Note that this op is not exposed to users directly, but is invoked in tf.data
+///   rewrites.
+///
+/// - Parameters:
+///   - arguments:     A list of tensors whose types are `Targuments`, corresponding to the inputs
+///         the function should be mapped over.
+///   - captured_inputs:     A list of tensors whose types are `Tcaptured`, corresponding to the captured
+///         inputs of the defun.
+///
+/// - Attrs:
+///   - Targuments: A list of types.
+///   - Tcaptured: A list of types.
+///   - output_types: A list of types.
+///   - output_shapes: A list of shapes.
+///
+/// - Output output:     A list of output tensors whose types are `output_types` and whose dimensions
+///       0 are the same as the dimensions 0 of the tensors in `arguments`, and whose
+///       remaining dimensions correspond to those in `output_shapes`.
+@inlinable @inline(__always)
+public static func mapDefun<
+    Targuments: TensorArrayProtocol,
+    Tcaptured: TensorArrayProtocol,
+    OutputTypes: TensorGroup,
+    FIn: TensorGroup,
+    FOut: TensorGroup
+>(
+  arguments: Targuments,
+  capturedInputs: Tcaptured,
+  outputShapes: [TensorShape?],
+  f: (FIn) -> FOut,
+  maxIntraOpParallelism: Int64 = 1
+) -> OutputTypes {
+  let op = TFE_Op("MapDefun")
+  op.setAttr("Targuments", arguments._typeList)
+  op.setAttr("Tcaptured", capturedInputs._typeList)
+  op.setAttr("output_types", OutputTypes._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("f", f)
+  op.setAttr("max_intra_op_parallelism", maxIntraOpParallelism)
+  let _ = op.addInputList(arguments)
+  let _ = op.addInputList(capturedInputs)
+  return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Op returns the number of incomplete elements in the underlying container.
+@inlinable @inline(__always)
+public static func mapIncompleteSize(
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  dtypes: [TensorDataType],
+  container: String,
+  sharedName: String
+) -> Tensor<Int32> {
+  let op = TFE_Op("MapIncompleteSize")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", dtypes)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Op peeks at the values at the specified key.  If the
+///
+/// underlying container does not contain this key
+/// this op will block until it does.
+@inlinable @inline(__always)
+public static func mapPeek<Dtypes: TensorGroup>(
+  key: Tensor<Int64>,
+  indices: Tensor<Int32>,
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  container: String,
+  sharedName: String
+) -> Dtypes {
+  let op = TFE_Op("MapPeek")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", Dtypes._typeList)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(key)
+  let _ = op.addInput(indices)
+  return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// Op returns the number of elements in the underlying container.
+@inlinable @inline(__always)
+public static func mapSize(
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  dtypes: [TensorDataType],
+  container: String,
+  sharedName: String
+) -> Tensor<Int32> {
+  let op = TFE_Op("MapSize")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", dtypes)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Stage (key, values) in the underlying container which behaves like a hashtable.
+///
+/// - Parameters:
+///   - key: int64
+///   - values: a list of tensors
+///     dtypes A list of data types that inserted values should adhere to.
+///
+/// - Attrs:
+///   - capacity: Maximum number of elements in the Staging Area. If > 0, inserts
+///     on the container will block when the capacity is reached.
+///   - container: If non-empty, this queue is placed in the given container. Otherwise,
+///     a default container is used.
+///   - shared_name: It is necessary to match this name to the matching Unstage Op.
+@inlinable @inline(__always)
+public static func mapStage<FakeDtypes: TensorArrayProtocol>(
+  key: Tensor<Int64>,
+  indices: Tensor<Int32>,
+  _ values: FakeDtypes,
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  dtypes: [TensorDataType],
+  container: String,
+  sharedName: String
+) {
+  let op = TFE_Op("MapStage")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", dtypes)
+  op.setAttr("fake_dtypes", values._typeList)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(key)
+  let _ = op.addInput(indices)
+  let _ = op.addInputList(values)
+  op.execute()
+}
+
+/// Op removes and returns the values associated with the key
+///
+/// from the underlying container.   If the underlying container
+/// does not contain this key, the op will block until it does.
+@inlinable @inline(__always)
+public static func mapUnstage<Dtypes: TensorGroup>(
+  key: Tensor<Int64>,
+  indices: Tensor<Int32>,
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  container: String,
+  sharedName: String
+) -> Dtypes {
+  let op = TFE_Op("MapUnstage")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", Dtypes._typeList)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(key)
+  let _ = op.addInput(indices)
+  return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// Op removes and returns a random (key, value)
+///
+/// from the underlying container.   If the underlying container
+/// does not contain elements, the op will block until it does.
+@inlinable @inline(__always)
+public static func mapUnstageNoKey<Dtypes: TensorGroup>(
+  indices: Tensor<Int32>,
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  container: String,
+  sharedName: String
+) -> (key: Tensor<Int64>, values: Dtypes) {
+  let op = TFE_Op("MapUnstageNoKey")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", Dtypes._typeList)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(indices)
+  return op.execute(Int(1), Int(Dtypes._typeList.count))
+}
+
+/// Multiply the matrix "a" by the matrix "b".
+///
+/// The inputs must be two-dimensional matrices and the inner dimension of
+/// "a" (after being transposed if transpose_a is true) must match the
+/// outer dimension of "b" (after being transposed if transposed_b is
+/// true).
+///
+/// *Note*: The default kernel implementation for MatMul on GPUs uses
+/// cublas.
+///
+/// - Attrs:
+///   - transpose_a: If true, "a" is transposed before multiplication.
+///   - transpose_b: If true, "b" is transposed before multiplication.
+@inlinable @inline(__always)
+public static func matMul<T: Numeric & TensorFlowScalar>(
+  _ a: Tensor<T>,
+  _ b: Tensor<T>,
+  transposeA: Bool = false,
+  transposeB: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("MatMul")
+  op.setAttr("transpose_a", transposeA)
+  op.setAttr("transpose_b", transposeB)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  return op.execute(Int(1))
+}
+
+/// Returns the set of files matching one or more glob patterns.
+///
+/// Note that this routine only supports wildcard characters in the
+/// basename portion of the pattern, not in the directory portion.
+/// Note also that the order of filenames returned can be non-deterministic.
+///
+/// - Parameter pattern: Shell wildcard pattern(s). Scalar or vector of type string.
+///
+/// - Output filenames: A vector of matching filenames.
+@inlinable @inline(__always)
+public static func matchingFiles(
+  pattern: StringTensor
+) -> StringTensor {
+  let op = TFE_Op("MatchingFiles")
+  let _ = op.addInput(pattern)
+  return op.execute(Int(1))
+}
+
+/// Copy a tensor setting everything outside a central band in each innermost matrix
+///
+/// to zero.
+///
+/// The `band` part is computed as follows:
+/// Assume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a
+/// tensor with the same shape where
+///
+/// `band[i, j, k, ..., m, n] = in_band(m, n) * input[i, j, k, ..., m, n]`.
+///
+/// The indicator function
+///
+/// `in_band(m, n) = (num_lower < 0 || (m-n) <= num_lower)) &&
+///                  (num_upper < 0 || (n-m) <= num_upper)`.
+///
+/// For example:
+///
+/// ```
+/// # if 'input' is [[ 0,  1,  2, 3]
+///                  [-1,  0,  1, 2]
+///                  [-2, -1,  0, 1]
+///                  [-3, -2, -1, 0]],
+///
+/// tf.matrix_band_part(input, 1, -1) ==> [[ 0,  1,  2, 3]
+///                                        [-1,  0,  1, 2]
+///                                        [ 0, -1,  0, 1]
+///                                        [ 0,  0, -1, 0]],
+///
+/// tf.matrix_band_part(input, 2, 1) ==> [[ 0,  1,  0, 0]
+///                                       [-1,  0,  1, 0]
+///                                       [-2, -1,  0, 1]
+///                                       [ 0, -2, -1, 0]]
+/// ```
+///
+/// Useful special cases:
+///
+/// ```
+///  tf.matrix_band_part(input, 0, -1) ==> Upper triangular part.
+///  tf.matrix_band_part(input, -1, 0) ==> Lower triangular part.
+///  tf.matrix_band_part(input, 0, 0) ==> Diagonal.
+/// ```
+///
+/// - Parameters:
+///   - input: Rank `k` tensor.
+///   - num_lower: 0-D tensor. Number of subdiagonals to keep. If negative, keep entire
+///     lower triangle.
+///   - num_upper: 0-D tensor. Number of superdiagonals to keep. If negative, keep
+///     entire upper triangle.
+///
+/// - Output band: Rank `k` tensor of the same shape as input. The extracted banded tensor.
+@inlinable @inline(__always)
+public static func matrixBandPart<
+    T: TensorFlowScalar,
+    Tindex: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  numLower: Tensor<Tindex>,
+  numUpper: Tensor<Tindex>
+) -> Tensor<T> {
+  let op = TFE_Op("MatrixBandPart")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindex", Tindex.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(numLower)
+  let _ = op.addInput(numUpper)
+  return op.execute(Int(1))
+}
+
+/// Computes the determinant of one or more square matrices.
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices. The output is a tensor containing the determinants
+/// for all input submatrices `[..., :, :]`.
+///
+/// - Parameter input: Shape is `[..., M, M]`.
+///
+/// - Output output: Shape is `[...]`.
+@inlinable @inline(__always)
+public static func matrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("MatrixDeterminant")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Returns a batched diagonal tensor with a given batched diagonal values.
+///
+/// Given a `diagonal`, this operation returns a tensor with the `diagonal` and
+/// everything else padded with zeros. The diagonal is computed as follows:
+///
+/// Assume `diagonal` has `k` dimensions `[I, J, K, ..., N]`, then the output is a
+/// tensor of rank `k+1` with dimensions [I, J, K, ..., N, N]` where:
+///
+/// `output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n]`.
+///
+/// For example:
+///
+/// ```
+/// # 'diagonal' is [[1, 2, 3, 4], [5, 6, 7, 8]]
+///
+/// and diagonal.shape = (2, 4)
+///
+/// tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0]
+///                                      [0, 2, 0, 0]
+///                                      [0, 0, 3, 0]
+///                                      [0, 0, 0, 4]],
+///                                     [[5, 0, 0, 0]
+///                                      [0, 6, 0, 0]
+///                                      [0, 0, 7, 0]
+///                                      [0, 0, 0, 8]]]
+///
+/// which has shape (2, 4, 4)
+/// ```
+///
+/// - Parameter diagonal: Rank `k`, where `k >= 1`.
+///
+/// - Output output: Rank `k+1`, with `output.shape = diagonal.shape + [diagonal.shape[-1]]`.
+@inlinable @inline(__always)
+public static func matrixDiag<T: TensorFlowScalar>(
+  diagonal: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("MatrixDiag")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(diagonal)
+  return op.execute(Int(1))
+}
+
+/// Returns the batched diagonal part of a batched tensor.
+///
+/// This operation returns a tensor with the `diagonal` part
+/// of the batched `input`. The `diagonal` part is computed as follows:
+///
+/// Assume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a
+/// tensor of rank `k - 1` with dimensions `[I, J, K, ..., min(M, N)]` where:
+///
+/// `diagonal[i, j, k, ..., n] = input[i, j, k, ..., n, n]`.
+///
+/// The input must be at least a matrix.
+///
+/// For example:
+///
+/// ```
+/// # 'input' is [[[1, 0, 0, 0]
+///                [0, 2, 0, 0]
+///                [0, 0, 3, 0]
+///                [0, 0, 0, 4]],
+///               [[5, 0, 0, 0]
+///                [0, 6, 0, 0]
+///                [0, 0, 7, 0]
+///                [0, 0, 0, 8]]]
+///
+/// and input.shape = (2, 4, 4)
+///
+/// tf.matrix_diag_part(input) ==> [[1, 2, 3, 4], [5, 6, 7, 8]]
+///
+/// which has shape (2, 4)
+/// ```
+///
+/// - Parameter input: Rank `k` tensor where `k >= 2`.
+///
+/// - Output diagonal: The extracted diagonal(s) having shape
+///   `diagonal.shape = input.shape[:-2] + [min(input.shape[-2:])]`.
+@inlinable @inline(__always)
+public static func matrixDiagPart<T: TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("MatrixDiagPart")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Deprecated, use python implementation tf.linalg.matrix_exponential.
+@inlinable @inline(__always)
+public static func matrixExponential<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("MatrixExponential")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Computes the inverse of one or more square invertible matrices or their
+///
+/// adjoints (conjugate transposes).
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices. The output is a tensor of the same shape as the input
+/// containing the inverse for all input submatrices `[..., :, :]`.
+///
+/// The op uses LU decomposition with partial pivoting to compute the inverses.
+///
+/// If a matrix is not invertible there is no guarantee what the op does. It
+/// may detect the condition and raise an exception or it may simply return a
+/// garbage result.
+///
+/// - Parameter input: Shape is `[..., M, M]`.
+///
+/// - Output output: Shape is `[..., M, M]`.
+///
+///   @compatibility(numpy)
+///   Equivalent to np.linalg.inv
+///   @end_compatibility
+@inlinable @inline(__always)
+public static func matrixInverse<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  adjoint: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("MatrixInverse")
+  op.setAttr("adjoint", adjoint)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Computes the matrix logarithm of one or more square matrices:
+///
+///
+/// \\(log(exp(A)) = A\\)
+///
+/// This op is only defined for complex matrices. If A is positive-definite and
+/// real, then casting to a complex matrix, taking the logarithm and casting back
+/// to a real matrix will give the correct result.
+///
+/// This function computes the matrix logarithm using the Schur-Parlett algorithm.
+/// Details of the algorithm can be found in Section 11.6.2 of:
+/// Nicholas J. Higham, Functions of Matrices: Theory and Computation, SIAM 2008.
+/// ISBN 978-0-898716-46-7.
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices. The output is a tensor of the same shape as the input
+/// containing the exponential for all input submatrices `[..., :, :]`.
+///
+/// - Parameter input: Shape is `[..., M, M]`.
+///
+/// - Output output: Shape is `[..., M, M]`.
+///
+///   @compatibility(scipy)
+///   Equivalent to scipy.linalg.logm
+///   @end_compatibility
+@inlinable @inline(__always)
+public static func matrixLogarithm<T: TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("MatrixLogarithm")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(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`.
+///
+/// - Parameters:
+///   - input: Rank `k+1`, where `k >= 1`.
+///   - diagonal: Rank `k`, where `k >= 1`.
+///
+/// - Output output: Rank `k+1`, with `output.shape = input.shape`.
+@inlinable @inline(__always)
+public static func matrixSetDiag<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  diagonal: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("MatrixSetDiag")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(diagonal)
+  return op.execute(Int(1))
+}
+
+/// Solves systems of linear equations.
+///
+/// `Matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices. `Rhs` is a tensor of shape `[..., M, K]`. The `output` is
+/// a tensor shape `[..., M, K]`.  If `adjoint` is `False` then each output matrix
+/// satisfies `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
+/// If `adjoint` is `True` then each output matrix satisfies
+/// `adjoint(matrix[..., :, :]) * output[..., :, :] = rhs[..., :, :]`.
+///
+/// - Parameters:
+///   - matrix: Shape is `[..., M, M]`.
+///   - rhs: Shape is `[..., M, K]`.
+///
+/// - Attr adjoint: Boolean indicating whether to solve with `matrix` or its (block-wise)
+///   adjoint.
+///
+/// - Output output: Shape is `[..., M, K]`.
+@inlinable @inline(__always)
+public static func matrixSolve<T: FloatingPoint & TensorFlowScalar>(
+  matrix: Tensor<T>,
+  rhs: Tensor<T>,
+  adjoint: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("MatrixSolve")
+  op.setAttr("adjoint", adjoint)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(matrix)
+  let _ = op.addInput(rhs)
+  return op.execute(Int(1))
+}
+
+/// Solves one or more linear least-squares problems.
+///
+/// `matrix` is a tensor of shape `[..., M, N]` whose inner-most 2 dimensions
+/// form real or complex matrices of size `[M, N]`. `Rhs` is a tensor of the same
+/// type as `matrix` and shape `[..., M, K]`.
+/// The output is a tensor shape `[..., N, K]` where each output matrix solves
+/// each of the equations
+/// `matrix[..., :, :]` * `output[..., :, :]` = `rhs[..., :, :]`
+/// in the least squares sense.
+///
+/// We use the following notation for (complex) matrix and right-hand sides
+/// in the batch:
+///
+/// `matrix`=\\(A \in \mathbb{C}^{m \times n}\\),
+/// `rhs`=\\(B  \in \mathbb{C}^{m \times k}\\),
+/// `output`=\\(X  \in \mathbb{C}^{n \times k}\\),
+/// `l2_regularizer`=\\(\lambda \in \mathbb{R}\\).
+///
+/// If `fast` is `True`, then the solution is computed by solving the normal
+/// equations using Cholesky decomposition. Specifically, if \\(m \ge n\\) then
+/// \\(X = (A^H A + \lambda I)^{-1} A^H B\\), which solves the least-squares
+/// problem \\(X = \mathrm{argmin}_{Z \in \Re^{n \times k} } ||A Z - B||_F^2 + \lambda ||Z||_F^2\\). 
+/// If \\(m \lt n\\) then `output` is computed as
+/// \\(X = A^H (A A^H + \lambda I)^{-1} B\\), which (for \\(\lambda = 0\\)) is the
+/// minimum-norm solution to the under-determined linear system, i.e.
+/// \\(X = \mathrm{argmin}_{Z \in \mathbb{C}^{n \times k} } ||Z||_F^2 \\),
+/// subject to \\(A Z = B\\). Notice that the fast path is only numerically stable
+/// when \\(A\\) is numerically full rank and has a condition number
+/// \\(\mathrm{cond}(A) \lt \frac{1}{\sqrt{\epsilon_{mach} } }\\) or \\(\lambda\\) is
+/// sufficiently large.
+///
+/// If `fast` is `False` an algorithm based on the numerically robust complete
+/// orthogonal decomposition is used. This computes the minimum-norm
+/// least-squares solution, even when \\(A\\) is rank deficient. This path is
+/// typically 6-7 times slower than the fast path. If `fast` is `False` then
+/// `l2_regularizer` is ignored.
+///
+/// - Parameters:
+///   - matrix: Shape is `[..., M, N]`.
+///   - rhs: Shape is `[..., M, K]`.
+///   - l2_regularizer: Scalar tensor.
+///
+///     @compatibility(numpy)
+///     Equivalent to np.linalg.lstsq
+///     @end_compatibility
+///
+/// - Output output: Shape is `[..., N, K]`.
+@inlinable @inline(__always)
+public static func matrixSolveLs<T: FloatingPoint & TensorFlowScalar>(
+  matrix: Tensor<T>,
+  rhs: Tensor<T>,
+  l2Regularizer: Tensor<Double>,
+  fast: Bool = true
+) -> Tensor<T> {
+  let op = TFE_Op("MatrixSolveLs")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("fast", fast)
+  let _ = op.addInput(matrix)
+  let _ = op.addInput(rhs)
+  let _ = op.addInput(l2Regularizer)
+  return op.execute(Int(1))
+}
+
+/// Computes the matrix square root of one or more square matrices:
+///
+/// matmul(sqrtm(A), sqrtm(A)) = A
+///
+/// The input matrix should be invertible. If the input matrix is real, it should
+/// have no eigenvalues which are real and negative (pairs of complex conjugate
+/// eigenvalues are allowed).
+///
+/// The matrix square root is computed by first reducing the matrix to 
+/// quasi-triangular form with the real Schur decomposition. The square root 
+/// of the quasi-triangular matrix is then computed directly. Details of 
+/// the algorithm can be found in: Nicholas J. Higham, "Computing real 
+/// square roots of a real matrix", Linear Algebra Appl., 1987.
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices. The output is a tensor of the same shape as the input
+/// containing the matrix square root for all input submatrices `[..., :, :]`.
+///
+/// - Parameter input: Shape is `[..., M, M]`.
+///
+/// - Output output: Shape is `[..., M, M]`.
+///
+///   @compatibility(scipy)
+///   Equivalent to scipy.linalg.sqrtm
+///   @end_compatibility
+@inlinable @inline(__always)
+public static func matrixSquareRoot<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("MatrixSquareRoot")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Solves systems of linear equations with upper or lower triangular matrices by
+///
+/// backsubstitution.
+///
+/// `matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions form
+/// square matrices. If `lower` is `True` then the strictly upper triangular part
+/// of each inner-most matrix is assumed to be zero and not accessed.
+/// If `lower` is False then the strictly lower triangular part of each inner-most
+/// matrix is assumed to be zero and not accessed.
+/// `rhs` is a tensor of shape `[..., M, K]`.
+///
+/// The output is a tensor of shape `[..., M, K]`. If `adjoint` is
+/// `True` then the innermost matrices in `output` satisfy matrix equations
+/// `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
+/// If `adjoint` is `False` then the strictly then the  innermost matrices in
+/// `output` satisfy matrix equations
+/// `adjoint(matrix[..., i, k]) * output[..., k, j] = rhs[..., i, j]`.
+///
+/// - Parameters:
+///   - matrix: Shape is `[..., M, M]`.
+///   - rhs: Shape is `[..., M, K]`.
+///
+/// - Attrs:
+///   - lower: Boolean indicating whether the innermost matrices in `matrix` are
+///     lower or upper triangular.
+///   - adjoint: Boolean indicating whether to solve with `matrix` or its (block-wise)
+///              adjoint.
+///
+///     @compatibility(numpy)
+///     Equivalent to scipy.linalg.solve_triangular
+///     @end_compatibility
+///
+/// - Output output: Shape is `[..., M, K]`.
+@inlinable @inline(__always)
+public static func matrixTriangularSolve<T: FloatingPoint & TensorFlowScalar>(
+  matrix: Tensor<T>,
+  rhs: Tensor<T>,
+  lower: Bool = true,
+  adjoint: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("MatrixTriangularSolve")
+  op.setAttr("lower", lower)
+  op.setAttr("adjoint", adjoint)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(matrix)
+  let _ = op.addInput(rhs)
+  return op.execute(Int(1))
+}
+
+/// Computes the maximum of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///   - input: The tensor to reduce.
+///   - reduction_indices: The dimensions to reduce. Must be in the range
+///     `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func max<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  reductionIndices: Tensor<Tidx>,
+  keepDims: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("Max")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(reductionIndices)
+  return op.execute(Int(1))
+}
+
+/// Performs max pooling on the input.
+///
+/// - Parameter input: 4-D input to pool over.
+///
+/// - Attrs:
+///   - ksize: The size of the window for each dimension of the input tensor.
+///   - strides: The stride of the sliding window for each dimension of the
+///     input tensor.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, in_channels, in_height, in_width].
+///
+/// - Output output: The max pooled output tensor.
+@inlinable @inline(__always)
+public static func maxPool<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat4 = .nhwc
+) -> Tensor<T> {
+  let op = TFE_Op("MaxPool")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Performs 3D max pooling on the input.
+///
+/// - Parameter input: Shape `[batch, depth, rows, cols, channels]` tensor to pool over.
+///
+/// - Attrs:
+///   - ksize: 1-D tensor of length 5. The size of the window for each dimension of
+///     the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: The data format of the input and output data. With the
+///     default format "NDHWC", the data is stored in the order of:
+///         [batch, in_depth, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCDHW", the data storage order is:
+///         [batch, in_channels, in_depth, in_height, in_width].
+///
+/// - Output output: The max pooled output tensor.
+@inlinable @inline(__always)
+public static func maxPool3D<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat1 = .ndhwc
+) -> Tensor<T> {
+  let op = TFE_Op("MaxPool3D")
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Computes gradients of max pooling function.
+///
+/// - Parameters:
+///   - orig_input: The original input tensor.
+///   - orig_output: The original output tensor.
+///   - grad: Output backprop of shape `[batch, depth, rows, cols, channels]`.
+///
+/// - Attrs:
+///   - ksize: 1-D tensor of length 5. The size of the window for each dimension of
+///     the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: The data format of the input and output data. With the
+///     default format "NDHWC", the data is stored in the order of:
+///         [batch, in_depth, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCDHW", the data storage order is:
+///         [batch, in_channels, in_depth, in_height, in_width].
+@inlinable @inline(__always)
+public static func maxPool3DGrad<
+    T: FloatingPoint & TensorFlowScalar,
+    Tinput: FloatingPoint & TensorFlowScalar
+>(
+  origInput: Tensor<Tinput>,
+  origOutput: Tensor<Tinput>,
+  grad: Tensor<T>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat1 = .ndhwc
+) -> Tensor<T> {
+  let op = TFE_Op("MaxPool3DGrad")
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("TInput", Tinput.tensorFlowDataType)
+  let _ = op.addInput(origInput)
+  let _ = op.addInput(origOutput)
+  let _ = op.addInput(grad)
+  return op.execute(Int(1))
+}
+
+/// Computes second-order gradients of the maxpooling function.
+///
+/// - Parameters:
+///   - orig_input: The original input tensor.
+///   - orig_output: The original output tensor.
+///   - grad: Output backprop of shape `[batch, depth, rows, cols, channels]`.
+///
+/// - Attrs:
+///   - ksize: 1-D tensor of length 5. The size of the window for each dimension of
+///     the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: The data format of the input and output data. With the
+///     default format "NDHWC", the data is stored in the order of:
+///         [batch, in_depth, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCDHW", the data storage order is:
+///         [batch, in_channels, in_depth, in_height, in_width].
+///
+/// - Output output: Gradients of gradients w.r.t. the input to `max_pool`.
+@inlinable @inline(__always)
+public static func maxPool3DGradGrad<T: Numeric & TensorFlowScalar>(
+  origInput: Tensor<T>,
+  origOutput: Tensor<T>,
+  grad: Tensor<T>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat1 = .ndhwc
+) -> Tensor<T> {
+  let op = TFE_Op("MaxPool3DGradGrad")
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(origInput)
+  let _ = op.addInput(origOutput)
+  let _ = op.addInput(grad)
+  return op.execute(Int(1))
+}
+
+/// Computes gradients of the maxpooling function.
+///
+/// - Parameters:
+///   - orig_input: The original input tensor.
+///   - orig_output: The original output tensor.
+///   - grad: 4-D.  Gradients w.r.t. the output of `max_pool`.
+///
+/// - Attrs:
+///   - ksize: The size of the window for each dimension of the input tensor.
+///   - strides: The stride of the sliding window for each dimension of the
+///     input tensor.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, in_channels, in_height, in_width].
+///
+/// - Output output: Gradients w.r.t. the input to `max_pool`.
+@inlinable @inline(__always)
+public static func maxPoolGrad<T: Numeric & TensorFlowScalar>(
+  origInput: Tensor<T>,
+  origOutput: Tensor<T>,
+  grad: Tensor<T>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let op = TFE_Op("MaxPoolGrad")
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(origInput)
+  let _ = op.addInput(origOutput)
+  let _ = op.addInput(grad)
+  return op.execute(Int(1))
+}
+
+/// Computes second-order gradients of the maxpooling function.
+///
+/// - Parameters:
+///   - orig_input: The original input tensor.
+///   - orig_output: The original output tensor.
+///   - grad: 4-D.  Gradients of gradients w.r.t. the input of `max_pool`.
+///
+/// - Attrs:
+///   - ksize: The size of the window for each dimension of the input tensor.
+///   - strides: The stride of the sliding window for each dimension of the
+///     input tensor.
+///   - padding: The type of padding algorithm to use.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, in_channels, in_height, in_width].
+///
+/// - Output output: Gradients of gradients w.r.t. the input to `max_pool`.
+@inlinable @inline(__always)
+public static func maxPoolGradGrad<T: Numeric & TensorFlowScalar>(
+  origInput: Tensor<T>,
+  origOutput: Tensor<T>,
+  grad: Tensor<T>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let op = TFE_Op("MaxPoolGradGrad")
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(origInput)
+  let _ = op.addInput(origOutput)
+  let _ = op.addInput(grad)
+  return op.execute(Int(1))
+}
+
+/// Computes second-order gradients of the maxpooling function.
+///
+/// - Parameters:
+///   - orig_input: The original input tensor.
+///   - orig_output: The original output tensor.
+///   - grad: 4-D.  Gradients of gradients w.r.t. the input of `max_pool`.
+///   - ksize: The size of the window for each dimension of the input tensor.
+///   - strides: The stride of the sliding window for each dimension of the
+///     input tensor.
+///
+/// - Attrs:
+///   - padding: The type of padding algorithm to use.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, in_channels, in_height, in_width].
+///
+/// - Output output: Gradients of gradients w.r.t. the input to `max_pool`.
+@inlinable @inline(__always)
+public static func maxPoolGradGradV2<T: Numeric & TensorFlowScalar>(
+  origInput: Tensor<T>,
+  origOutput: Tensor<T>,
+  grad: Tensor<T>,
+  ksize: Tensor<Int32>,
+  strides: Tensor<Int32>,
+  padding: Padding,
+  dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let op = TFE_Op("MaxPoolGradGradV2")
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(origInput)
+  let _ = op.addInput(origOutput)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(ksize)
+  let _ = op.addInput(strides)
+  return op.execute(Int(1))
+}
+
+/// Computes second-order gradients of the maxpooling function.
+///
+/// - Parameters:
+///   - input: The original input.
+///   - grad: 4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t. the
+///     input of `max_pool`.
+///   - argmax: The indices of the maximum values chosen for each output of `max_pool`.
+///
+/// - Attrs:
+///   - ksize: The size of the window for each dimension of the input tensor.
+///   - strides: The stride of the sliding window for each dimension of the
+///     input tensor.
+///   - padding: The type of padding algorithm to use.
+///   - include_batch_in_index: Whether to include batch dimension in flattened index of `argmax`.
+///
+/// - Output output: Gradients of gradients w.r.t. the input of `max_pool`.
+@inlinable @inline(__always)
+public static func maxPoolGradGradWithArgmax<
+    Targmax: BinaryInteger & TensorFlowScalar,
+    T: Numeric & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  grad: Tensor<T>,
+  argmax: Tensor<Targmax>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  includeBatchInIndex: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("MaxPoolGradGradWithArgmax")
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("include_batch_in_index", includeBatchInIndex)
+  op.setAttr("Targmax", Targmax.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(argmax)
+  return op.execute(Int(1))
+}
+
+/// Computes gradients of the maxpooling function.
+///
+/// - Parameters:
+///   - orig_input: The original input tensor.
+///   - orig_output: The original output tensor.
+///   - grad: 4-D.  Gradients w.r.t. the output of `max_pool`.
+///   - ksize: The size of the window for each dimension of the input tensor.
+///   - strides: The stride of the sliding window for each dimension of the
+///     input tensor.
+///
+/// - Attrs:
+///   - padding: The type of padding algorithm to use.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, in_channels, in_height, in_width].
+///
+/// - Output output: Gradients w.r.t. the input to `max_pool`.
+@inlinable @inline(__always)
+public static func maxPoolGradV2<T: Numeric & TensorFlowScalar>(
+  origInput: Tensor<T>,
+  origOutput: Tensor<T>,
+  grad: Tensor<T>,
+  ksize: Tensor<Int32>,
+  strides: Tensor<Int32>,
+  padding: Padding,
+  dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let op = TFE_Op("MaxPoolGradV2")
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(origInput)
+  let _ = op.addInput(origOutput)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(ksize)
+  let _ = op.addInput(strides)
+  return op.execute(Int(1))
+}
+
+/// Computes gradients of the maxpooling function.
+///
+/// - Parameters:
+///   - input: The original input.
+///   - grad: 4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t. the
+///     output of `max_pool`.
+///   - argmax: The indices of the maximum values chosen for each output of `max_pool`.
+///
+/// - Attrs:
+///   - ksize: The size of the window for each dimension of the input tensor.
+///   - strides: The stride of the sliding window for each dimension of the
+///     input tensor.
+///   - padding: The type of padding algorithm to use.
+///   - include_batch_in_index: Whether to include batch dimension in flattened index of `argmax`.
+///
+/// - Output output: Gradients w.r.t. the input of `max_pool`.
+@inlinable @inline(__always)
+public static func maxPoolGradWithArgmax<
+    Targmax: BinaryInteger & TensorFlowScalar,
+    T: Numeric & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  grad: Tensor<T>,
+  argmax: Tensor<Targmax>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  includeBatchInIndex: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("MaxPoolGradWithArgmax")
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("include_batch_in_index", includeBatchInIndex)
+  op.setAttr("Targmax", Targmax.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(argmax)
+  return op.execute(Int(1))
+}
+
+/// Performs max pooling on the input.
+///
+/// - Parameters:
+///   - input: 4-D input to pool over.
+///   - ksize: The size of the window for each dimension of the input tensor.
+///   - strides: The stride of the sliding window for each dimension of the
+///     input tensor.
+///
+/// - Attrs:
+///   - padding: The type of padding algorithm to use.
+///   - data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the data is stored in the order of:
+///         [batch, in_height, in_width, in_channels].
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, in_channels, in_height, in_width].
+///
+/// - Output output: The max pooled output tensor.
+@inlinable @inline(__always)
+public static func maxPoolV2<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  ksize: Tensor<Int32>,
+  strides: Tensor<Int32>,
+  padding: Padding,
+  dataFormat: DataFormat4 = .nhwc
+) -> Tensor<T> {
+  let op = TFE_Op("MaxPoolV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("data_format", dataFormat.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(ksize)
+  let _ = op.addInput(strides)
+  return op.execute(Int(1))
+}
+
+/// Performs max pooling on the input and outputs both max values and indices.
+///
+/// The indices in `argmax` are flattened, so that a maximum value at position
+/// `[b, y, x, c]` becomes flattened index:
+/// `(y * width + x) * channels + c` if `include_batch_in_index` is False;
+/// `((b * height + y) * width + x) * channels + c` if `include_batch_in_index` is True.
+///
+/// The indices returned are always in `[0, height) x [0, width)` before flattening,
+/// even if padding is involved and the mathematically correct answer is outside
+/// (either negative or too large).  This is a bug, but fixing it is difficult to do
+/// in a safe backwards compatible way, especially due to flattening.
+///
+/// - Parameter input: 4-D with shape `[batch, height, width, channels]`.  Input to pool over.
+///
+/// - Attrs:
+///   - ksize: The size of the window for each dimension of the input tensor.
+///   - strides: The stride of the sliding window for each dimension of the
+///     input tensor.
+///   - padding: The type of padding algorithm to use.
+///   - include_batch_in_index: Whether to include batch dimension in flattened index of `argmax`.
+///
+/// - Outputs:
+///   - output: The max pooled output tensor.
+///   - argmax: 4-D.  The flattened indices of the max values chosen for each output.
+@inlinable @inline(__always)
+public static func maxPoolWithArgmax<
+    Targmax: BinaryInteger & TensorFlowScalar,
+    T: Numeric & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding,
+  includeBatchInIndex: Bool = false
+) -> (output: Tensor<T>, argmax: Tensor<Targmax>) {
+  let op = TFE_Op("MaxPoolWithArgmax")
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("Targmax", Targmax.tensorFlowDataType)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("include_batch_in_index", includeBatchInIndex)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Returns the max of x and y (i.e. x > y ? x : y) element-wise.
+///
+/// *NOTE*: `Maximum` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func maximum<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Maximum")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Computes the mean of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///   - input: The tensor to reduce.
+///   - reduction_indices: The dimensions to reduce. Must be in the range
+///     `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func mean<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  reductionIndices: Tensor<Tidx>,
+  keepDims: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("Mean")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(reductionIndices)
+  return op.execute(Int(1))
+}
+
+/// Forwards the value of an available tensor from `inputs` to `output`.
+///
+/// `Merge` waits for at least one of the tensors in `inputs` to become available.
+/// It is usually combined with `Switch` to implement branching.
+///
+/// `Merge` forwards the first tensor to become available to `output`, and sets
+/// `value_index` to its index in `inputs`.
+///
+/// - Parameter inputs: The input tensors, exactly one of which will become available.
+///
+/// - Outputs:
+///   - output: Will be set to the available input tensor.
+///   - value_index: The index of the chosen input tensor in `inputs`.
+@inlinable @inline(__always)
+public static func merge<T: TensorFlowScalar>(
+  inputs: [Tensor<T>]
+) -> (output: Tensor<T>, valueIndex: Tensor<Int32>) {
+  let op = TFE_Op("Merge")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("N", inputs.count)
+  let _ = op.addInputList(inputs)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Merges summaries.
+///
+/// This op creates a
+/// [`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto)
+/// protocol buffer that contains the union of all the values in the input
+/// summaries.
+///
+/// When the Op is run, it reports an `InvalidArgument` error if multiple values
+/// in the summaries to merge use the same tag.
+///
+/// - Parameter inputs: Can be of any shape.  Each must contain serialized `Summary` protocol
+///   buffers.
+///
+/// - Output summary: Scalar. Serialized `Summary` protocol buffer.
+@inlinable @inline(__always)
+public static func mergeSummary(
+  inputs: [StringTensor]
+) -> StringTensor {
+  let op = TFE_Op("MergeSummary")
+  op.setAttr("N", inputs.count)
+  let _ = op.addInputList(inputs)
+  return op.execute(Int(1))
+}
+
+/// V2 format specific: merges the metadata files of sharded checkpoints.  The
+///
+/// result is one logical checkpoint, with one physical metadata file and renamed
+/// data files.
+///
+/// Intended for "grouping" multiple checkpoints in a sharded checkpoint setup.
+///
+/// If delete_old_dirs is true, attempts to delete recursively the dirname of each
+/// path in the input checkpoint_prefixes.  This is useful when those paths are non
+/// user-facing temporary locations.
+///
+/// - Parameters:
+///   - checkpoint_prefixes: prefixes of V2 checkpoints to merge.
+///   - destination_prefix: scalar.  The desired final prefix.  Allowed to be the same
+///     as one of the checkpoint_prefixes.
+///
+/// - Attr delete_old_dirs: see above.
+@inlinable @inline(__always)
+public static func mergeV2Checkpoints(
+  checkpointPrefixes: StringTensor,
+  destinationPrefix: StringTensor,
+  deleteOldDirs: Bool = true
+) {
+  let op = TFE_Op("MergeV2Checkpoints")
+  op.setAttr("delete_old_dirs", deleteOldDirs)
+  let _ = op.addInput(checkpointPrefixes)
+  let _ = op.addInput(destinationPrefix)
+  op.execute()
+}
+
+/// Transforms a spectrogram into a form that's useful for speech recognition.
+///
+/// Mel Frequency Cepstral Coefficients are a way of representing audio data that's
+/// been effective as an input feature for machine learning. They are created by
+/// taking the spectrum of a spectrogram (a 'cepstrum'), and discarding some of the
+/// higher frequencies that are less significant to the human ear. They have a long
+/// history in the speech recognition world, and https://en.wikipedia.org/wiki/Mel-frequency_cepstrum
+/// is a good resource to learn more.
+///
+/// - Parameters:
+///   - spectrogram: Typically produced by the Spectrogram op, with magnitude_squared
+///     set to true.
+///   - sample_rate: How many samples per second the source audio used.
+///
+/// - Attrs:
+///   - upper_frequency_limit: The highest frequency to use when calculating the
+///     ceptstrum.
+///   - lower_frequency_limit: The lowest frequency to use when calculating the
+///     ceptstrum.
+///   - filterbank_channel_count: Resolution of the Mel bank used internally.
+///   - dct_coefficient_count: How many output channels to produce per time slice.
+@inlinable @inline(__always)
+public static func mfcc(
+  spectrogram: Tensor<Float>,
+  sampleRate: Tensor<Int32>,
+  upperFrequencyLimit: Double = 4000,
+  lowerFrequencyLimit: Double = 20,
+  filterbankChannelCount: Int64 = 40,
+  dctCoefficientCount: Int64 = 13
+) -> Tensor<Float> {
+  let op = TFE_Op("Mfcc")
+  op.setAttr("upper_frequency_limit", upperFrequencyLimit)
+  op.setAttr("lower_frequency_limit", lowerFrequencyLimit)
+  op.setAttr("filterbank_channel_count", filterbankChannelCount)
+  op.setAttr("dct_coefficient_count", dctCoefficientCount)
+  let _ = op.addInput(spectrogram)
+  let _ = op.addInput(sampleRate)
+  return op.execute(Int(1))
+}
+
+/// Computes the minimum of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///   - input: The tensor to reduce.
+///   - reduction_indices: The dimensions to reduce. Must be in the range
+///     `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func min<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  reductionIndices: Tensor<Tidx>,
+  keepDims: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("Min")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(reductionIndices)
+  return op.execute(Int(1))
+}
+
+/// Returns the min of x and y (i.e. x < y ? x : y) element-wise.
+///
+/// *NOTE*: `Minimum` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func minimum<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Minimum")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Pads a tensor with mirrored values.
+///
+/// This operation pads a `input` with mirrored values according to the `paddings`
+/// you specify. `paddings` is an integer tensor with shape `[n, 2]`, where n is
+/// the rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
+/// how many values to add before the contents of `input` in that dimension, and
+/// `paddings[D, 1]` indicates how many values to add after the contents of `input`
+/// in that dimension. Both `paddings[D, 0]` and `paddings[D, 1]` must be no greater
+/// than `input.dim_size(D)` (or `input.dim_size(D) - 1`) if `copy_border` is true
+/// (if false, respectively).
+///
+/// The padded size of each dimension D of the output is:
+///
+/// `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[1, 2, 3], [4, 5, 6]].
+/// # 'paddings' is [[1, 1]], [2, 2]].
+/// # 'mode' is SYMMETRIC.
+/// # rank of 't' is 2.
+/// pad(t, paddings) ==> [[2, 1, 1, 2, 3, 3, 2]
+///                       [2, 1, 1, 2, 3, 3, 2]
+///                       [5, 4, 4, 5, 6, 6, 5]
+///                       [5, 4, 4, 5, 6, 6, 5]]
+/// ```
+///
+/// - Parameters:
+///   - input: The input tensor to be padded.
+///   - paddings: A two-column matrix specifying the padding sizes. The number of
+///     rows must be the same as the rank of `input`.
+///
+/// - Attr mode: Either `REFLECT` or `SYMMETRIC`. In reflect mode the padded regions
+///   do not include the borders, while in symmetric mode the padded regions
+///   do include the borders. For example, if `input` is `[1, 2, 3]` and `paddings`
+///   is `[0, 2]`, then the output is `[1, 2, 3, 2, 1]` in reflect mode, and
+///   it is `[1, 2, 3, 3, 2]` in symmetric mode.
+///
+/// - Output output: The padded tensor.
+@inlinable @inline(__always)
+public static func mirrorPad<
+    T: TensorFlowScalar,
+    Tpaddings: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  paddings: Tensor<Tpaddings>,
+  mode: Mode5
+) -> Tensor<T> {
+  let op = TFE_Op("MirrorPad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tpaddings", Tpaddings.tensorFlowDataType)
+  op.setAttr("mode", mode.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(paddings)
+  return op.execute(Int(1))
+}
+
+/// Gradient op for `MirrorPad` op. This op folds a mirror-padded tensor.
+///
+/// This operation folds the padded areas of `input` by `MirrorPad` according to the
+/// `paddings` you specify. `paddings` must be the same as `paddings` argument
+/// given to the corresponding `MirrorPad` op.
+///
+/// The folded size of each dimension D of the output is:
+///
+/// `input.dim_size(D) - paddings(D, 0) - paddings(D, 1)`
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[1, 2, 3], [4, 5, 6], [7, 8, 9]].
+/// # 'paddings' is [[0, 1]], [0, 1]].
+/// # 'mode' is SYMMETRIC.
+/// # rank of 't' is 2.
+/// pad(t, paddings) ==> [[ 1,  5]
+///                       [11, 28]]
+/// ```
+///
+/// - Parameters:
+///   - input: The input tensor to be folded.
+///   - paddings: A two-column matrix specifying the padding sizes. The number of
+///     rows must be the same as the rank of `input`.
+///
+/// - Attr mode: The mode used in the `MirrorPad` op.
+///
+/// - Output output: The folded tensor.
+@inlinable @inline(__always)
+public static func mirrorPadGrad<
+    T: TensorFlowScalar,
+    Tpaddings: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  paddings: Tensor<Tpaddings>,
+  mode: Mode5
+) -> Tensor<T> {
+  let op = TFE_Op("MirrorPadGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tpaddings", Tpaddings.tensorFlowDataType)
+  op.setAttr("mode", mode.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(paddings)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func mixedStruct(
+  nA: Int64
+) -> (a: [Tensor<Int32>], b: Tensor<Float>) {
+  let op = TFE_Op("MixedStruct")
+  op.setAttr("n_a", nA)
+  return op.execute(Int(nA), Int(1))
+}
+
+/// Returns element-wise remainder of division. This emulates C semantics in that
+///
+/// the result here is consistent with a truncating divide. E.g.
+/// `tf.truncatediv(x, y) * y + truncate_mod(x, y) = x`.
+///
+/// *NOTE*: `Mod` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func mod<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Mod")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Identity transformation that models performance.
+///
+/// Identity transformation that models performance.
+///
+/// - Parameter input_dataset: A variant tensor representing the input dataset.
+@inlinable @inline(__always)
+public static func modelDataset(
+  inputDataset: VariantHandle,
+  cpuBudget: Int64 = 0,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ModelDataset")
+  op.setAttr("cpu_budget", cpuBudget)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  return op.execute(Int(1))
+}
+
+/// Returns x * y element-wise.
+///
+/// *NOTE*: `Multiply` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func mul<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Mul")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns x * y element-wise. Returns zero if y is zero, even if x if infinite or NaN.
+///
+/// *NOTE*: `Mul` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func mulNoNan<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("MulNoNan")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Creates a MultiDeviceIterator resource.
+///
+/// - Attrs:
+///   - devices: A list of devices the iterator works across.
+///   - shared_name: If non-empty, this resource will be shared under the given name
+///     across multiple sessions.
+///   - container: If non-empty, this resource is placed in the given container.
+///     Otherwise, a default container is used.
+///   - output_types: The type list for the return values.
+///   - output_shapes: The list of shapes being produced.
+///
+/// - Output handle: Handle to the resource created.
+@inlinable @inline(__always)
+public static func multiDeviceIterator(
+  devices: [String],
+  sharedName: String,
+  container: String,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let op = TFE_Op("MultiDeviceIterator")
+  op.setAttr("devices", devices)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("container", container)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  return op.execute(Int(1))
+}
+
+/// Generates a MultiDeviceIterator resource from its provided string handle.
+///
+/// - Parameter string_handle: String representing the resource.
+///
+/// - Attrs:
+///   - output_types: The type list for the return values.
+///   - output_shapes: The list of shapes being produced.
+///
+/// - Output multi_device_iterator: A MultiDeviceIterator resource.
+@inlinable @inline(__always)
+public static func multiDeviceIteratorFromStringHandle(
+  stringHandle: StringTensor,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let op = TFE_Op("MultiDeviceIteratorFromStringHandle")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(stringHandle)
+  return op.execute(Int(1))
+}
+
+/// Gets next element for the provided shard number.
+///
+/// - Parameters:
+///   - multi_device_iterator: A MultiDeviceIterator resource.
+///   - shard_num: Integer representing which shard to fetch data for.
+///   - incarnation_id: Which incarnation of the MultiDeviceIterator is running.
+///
+/// - Attrs:
+///   - output_types: The type list for the return values.
+///   - output_shapes: The list of shapes being produced.
+///
+/// - Output components: Result of the get_next on the dataset.
+@inlinable @inline(__always)
+public static func multiDeviceIteratorGetNextFromShard<OutputTypes: TensorGroup>(
+  multiDeviceIterator: ResourceHandle,
+  shardNum: Tensor<Int32>,
+  incarnationId: Tensor<Int64>,
+  outputShapes: [TensorShape?]
+) -> OutputTypes {
+  let op = TFE_Op("MultiDeviceIteratorGetNextFromShard")
+  op.setAttr("output_types", OutputTypes._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(multiDeviceIterator)
+  let _ = op.addInput(shardNum)
+  let _ = op.addInput(incarnationId)
+  return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Initializes the multi device iterator with the given dataset.
+///
+/// - Parameters:
+///   - dataset: Dataset to be iterated upon.
+///   - multi_device_iterator: A MultiDeviceIteratorResource.
+///   - max_buffer_size: The maximum size of the host side per device buffer to keep.
+///
+/// - Output incarnation_id: An int64 indicating which incarnation of the MultiDeviceIterator
+///   is running.
+@inlinable @inline(__always)
+public static func multiDeviceIteratorInit(
+  dataset: VariantHandle,
+  multiDeviceIterator: ResourceHandle,
+  maxBufferSize: Tensor<Int64>
+) -> Tensor<Int64> {
+  let op = TFE_Op("MultiDeviceIteratorInit")
+  let _ = op.addInput(dataset)
+  let _ = op.addInput(multiDeviceIterator)
+  let _ = op.addInput(maxBufferSize)
+  return op.execute(Int(1))
+}
+
+/// Produces a string handle for the given MultiDeviceIterator.
+///
+/// - Parameter multi_device_iterator: A MultiDeviceIterator resource.
+///
+/// - Output string_handle: A string representing the resource.
+@inlinable @inline(__always)
+public static func multiDeviceIteratorToStringHandle(
+  multiDeviceIterator: ResourceHandle
+) -> StringTensor {
+  let op = TFE_Op("MultiDeviceIteratorToStringHandle")
+  let _ = op.addInput(multiDeviceIterator)
+  return op.execute(Int(1))
+}
+
+/// Draws samples from a multinomial distribution.
+///
+/// - Parameters:
+///   - logits: 2-D Tensor with shape `[batch_size, num_classes]`.  Each slice `[i, :]`
+///     represents the unnormalized log probabilities for all classes.
+///   - num_samples: 0-D.  Number of independent samples to draw for each row slice.
+///
+/// - Attrs:
+///   - seed: If either seed or seed2 is set to be non-zero, the internal random number
+///     generator is seeded by the given seed.  Otherwise, a random seed is used.
+///   - seed2: A second seed to avoid seed collision.
+///
+/// - Output output: 2-D Tensor with shape `[batch_size, num_samples]`.  Each slice `[i, :]`
+///   contains the drawn class labels with range `[0, num_classes)`.
+@inlinable @inline(__always)
+public static func multinomial<
+    T: Numeric & TensorFlowScalar,
+    OutputDtype: BinaryInteger & TensorFlowScalar
+>(
+  logits: Tensor<T>,
+  numSamples: Tensor<Int32>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<OutputDtype> {
+  let op = TFE_Op("Multinomial")
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("output_dtype", OutputDtype.tensorFlowDataType)
+  let _ = op.addInput(logits)
+  let _ = op.addInput(numSamples)
+  return op.execute(Int(1))
+}
+
+/// Creates an empty hash table that uses tensors as the backing store.
+///
+/// It uses "open addressing" with quadratic reprobing to resolve
+/// collisions.
+///
+/// This op creates a mutable hash table, specifying the type of its keys and
+/// values. Each value must be a scalar. Data can be inserted into the table using
+/// the insert operations. It does not support the initialization operation.
+///
+/// - Parameter empty_key: The key used to represent empty key buckets internally. Must not
+///   be used in insert or lookup operations.
+///
+/// - Attrs:
+///   - container: If non-empty, this table is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this table is shared under the given name across
+///     multiple sessions.
+///   - key_dtype: Type of the table keys.
+///   - value_dtype: Type of the table values.
+///   - value_shape: The shape of each value.
+///   - initial_num_buckets: The initial number of hash table buckets. Must be a power
+///     to 2.
+///   - max_load_factor: The maximum ratio between number of entries and number of
+///     buckets before growing the table. Must be between 0 and 1.
+///
+/// - Output table_handle: Handle to a table.
+@inlinable @inline(__always)
+public static func mutableDenseHashTableV2<KeyDtype: TensorFlowScalar>(
+  emptyKey: Tensor<KeyDtype>,
+  deletedKey: Tensor<KeyDtype>,
+  container: String,
+  sharedName: String,
+  useNodeNameSharing: Bool = false,
+  valueDtype: TensorDataType,
+  valueShape: TensorShape?,
+  initialNumBuckets: Int64 = 131072,
+  maxLoadFactor: Double = 0.8
+) -> ResourceHandle {
+  let op = TFE_Op("MutableDenseHashTableV2")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("use_node_name_sharing", useNodeNameSharing)
+  op.setAttr("key_dtype", KeyDtype.tensorFlowDataType)
+  op.setAttr("value_dtype", valueDtype)
+  op.setAttr("value_shape", valueShape)
+  op.setAttr("initial_num_buckets", initialNumBuckets)
+  op.setAttr("max_load_factor", maxLoadFactor)
+  let _ = op.addInput(emptyKey)
+  let _ = op.addInput(deletedKey)
+  return op.execute(Int(1))
+}
+
+/// Creates an empty hash table.
+///
+/// This op creates a mutable hash table, specifying the type of its keys and
+/// values. Each value must be a vector. Data can be inserted into the table using
+/// the insert operations. It does not support the initialization operation.
+///
+/// - Attrs:
+///   - container: If non-empty, this table is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this table is shared under the given name across
+///     multiple sessions.
+///   - key_dtype: Type of the table keys.
+///   - value_dtype: Type of the table values.
+///
+/// - Output table_handle: Handle to a table.
+@inlinable @inline(__always)
+public static func mutableHashTableOfTensorsV2(
+  container: String,
+  sharedName: String,
+  useNodeNameSharing: Bool = false,
+  keyDtype: TensorDataType,
+  valueDtype: TensorDataType,
+  valueShape: TensorShape?
+) -> ResourceHandle {
+  let op = TFE_Op("MutableHashTableOfTensorsV2")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("use_node_name_sharing", useNodeNameSharing)
+  op.setAttr("key_dtype", keyDtype)
+  op.setAttr("value_dtype", valueDtype)
+  op.setAttr("value_shape", valueShape)
+  return op.execute(Int(1))
+}
+
+/// Creates an empty hash table.
+///
+/// This op creates a mutable hash table, specifying the type of its keys and
+/// values. Each value must be a scalar. Data can be inserted into the table using
+/// the insert operations. It does not support the initialization operation.
+///
+/// - Attrs:
+///   - container: If non-empty, this table is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this table is shared under the given name across
+///     multiple sessions.
+///   - use_node_name_sharing: If true and shared_name is empty, the table is shared
+///     using the node name.
+///   - key_dtype: Type of the table keys.
+///   - value_dtype: Type of the table values.
+///
+/// - Output table_handle: Handle to a table.
+@inlinable @inline(__always)
+public static func mutableHashTableV2(
+  container: String,
+  sharedName: String,
+  useNodeNameSharing: Bool = false,
+  keyDtype: TensorDataType,
+  valueDtype: TensorDataType
+) -> ResourceHandle {
+  let op = TFE_Op("MutableHashTableV2")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("use_node_name_sharing", useNodeNameSharing)
+  op.setAttr("key_dtype", keyDtype)
+  op.setAttr("value_dtype", valueDtype)
+  return op.execute(Int(1))
+}
+
+/// Locks a mutex resource.  The output is the lock.  So long as the lock tensor
+///
+/// is alive, any other request to use `MutexLock` with this mutex will wait.
+///
+/// This is particularly useful for creating a critical section when used in
+/// conjunction with `MutexLockIdentity`:
+///
+/// ```python
+///
+/// mutex = mutex_v2(
+///   shared_name=handle_name, container=container, name=name)
+///
+/// def execute_in_critical_section(fn, *args, **kwargs):
+///   lock = gen_resource_variable_ops.mutex_lock(mutex)
+///
+///   with ops.control_dependencies([lock]):
+///     r = fn(*args, **kwargs)
+///
+///   with ops.control_dependencies(nest.flatten(r)):
+///     with ops.colocate_with(mutex):
+///       ensure_lock_exists = mutex_lock_identity(lock)
+///
+///     # Make sure that if any element of r is accessed, all of
+///     # them are executed together.
+///     r = nest.map_structure(tf.identity, r)
+///
+///   with ops.control_dependencies([ensure_lock_exists]):
+///     return nest.map_structure(tf.identity, r)
+/// ```
+///
+/// While `fn` is running in the critical section, no other functions which wish to
+/// use this critical section may run.
+///
+/// Often the use case is that two executions of the same graph, in parallel,
+/// wish to run `fn`; and we wish to ensure that only one of them executes
+/// at a time.  This is especially important if `fn` modifies one or more
+/// variables at a time.
+///
+/// It is also useful if two separate functions must share a resource, but we
+/// wish to ensure the usage is exclusive.
+///
+/// - Parameter mutex: The mutex resource to lock.
+///
+/// - Output mutex_lock: A tensor that keeps a shared pointer to a lock on the mutex;
+///   when the Tensor is destroyed, the use count on the shared pointer is decreased
+///   by 1.  When it reaches 0, the lock is released.
+@inlinable @inline(__always)
+public static func mutexLock(
+  mutex: ResourceHandle
+) -> VariantHandle {
+  let op = TFE_Op("MutexLock")
+  let _ = op.addInput(mutex)
+  return op.execute(Int(1))
+}
+
+/// Creates a Mutex resource that can be locked by `MutexLock`.
+///
+/// - Attrs:
+///   - container: If non-empty, this variable is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this variable is named in the given bucket
+///     with this shared_name. Otherwise, the node name is used instead.
+///
+/// - Output resource: The mutex resource.
+@inlinable @inline(__always)
+public static func mutexV2(
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("MutexV2")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func nInPolymorphicTwice<T: TensorFlowScalar>(
+  _ a: [Tensor<T>],
+  _ b: [Tensor<T>]
+) {
+  let op = TFE_Op("NInPolymorphicTwice")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("N", a.count)
+  let _ = op.addInputList(a)
+  let _ = op.addInputList(b)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nInTwice(
+  _ a: [Tensor<Int32>],
+  _ b: [StringTensor]
+) {
+  let op = TFE_Op("NInTwice")
+  op.setAttr("N", a.count)
+  let _ = op.addInputList(a)
+  let _ = op.addInputList(b)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nInTwoTypeVariables<
+    S: TensorFlowScalar,
+    T: TensorFlowScalar
+>(
+  _ a: [Tensor<S>],
+  _ b: [Tensor<T>]
+) {
+  let op = TFE_Op("NInTwoTypeVariables")
+  op.setAttr("S", S.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("N", a.count)
+  let _ = op.addInputList(a)
+  let _ = op.addInputList(b)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nIntsIn(
+  _ a: [Tensor<Int32>]
+) {
+  let op = TFE_Op("NIntsIn")
+  op.setAttr("N", a.count)
+  let _ = op.addInputList(a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nIntsOut(
+  n: Int64
+) -> [Tensor<Int32>] {
+  let op = TFE_Op("NIntsOut")
+  op.setAttr("N", n)
+  return op.execute(Int(n))
+}
+
+@inlinable @inline(__always)
+public static func nIntsOutDefault(
+  n: Int64 = 3
+) -> [Tensor<Int32>] {
+  let op = TFE_Op("NIntsOutDefault")
+  op.setAttr("N", n)
+  return op.execute(Int(n))
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicIn<T: TensorFlowScalar>(
+  _ a: [Tensor<T>]
+) {
+  let op = TFE_Op("NPolymorphicIn")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("N", a.count)
+  let _ = op.addInputList(a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicOut<T: TensorFlowScalar>(
+  n: Int64
+) -> [Tensor<T>] {
+  let op = TFE_Op("NPolymorphicOut")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("N", n)
+  return op.execute(Int(n))
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicOutDefault<T: TensorFlowScalar>(
+  n: Int64 = 2
+) -> [Tensor<T>] {
+  let op = TFE_Op("NPolymorphicOutDefault")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("N", n)
+  return op.execute(Int(n))
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicRestrictIn<T: TensorFlowScalar>(
+  _ a: [Tensor<T>]
+) {
+  let op = TFE_Op("NPolymorphicRestrictIn")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("N", a.count)
+  let _ = op.addInputList(a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicRestrictIn(
+  _ a: [StringTensor]
+) {
+  let op = TFE_Op("NPolymorphicRestrictIn")
+  op.setAttr("T", TensorDataType(TF_STRING))
+  op.setAttr("N", a.count)
+  let _ = op.addInputList(a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicRestrictOut<T: TensorFlowScalar>(
+  n: Int64
+) -> [Tensor<T>] {
+  let op = TFE_Op("NPolymorphicRestrictOut")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("N", n)
+  return op.execute(Int(n))
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicRestrictOut(
+  n: Int64
+) -> [StringTensor] {
+  let op = TFE_Op("NPolymorphicRestrictOut")
+  op.setAttr("T", TensorDataType(TF_STRING))
+  op.setAttr("N", n)
+  return op.execute(Int(n))
+}
+
+/// Outputs a tensor containing the reduction across all input tensors.
+///
+/// Outputs a tensor containing the reduction across all input tensors passed to ops
+/// within the same `shared_name.
+///
+/// The graph should be constructed so if one op runs with shared_name value `c`,
+/// then `num_devices` ops will run with shared_name value `c`.  Failure to do so
+/// will cause the graph execution to fail to complete.
+///
+/// input: the input to the reduction
+/// data: the value of the reduction across all `num_devices` devices.
+/// reduction: the reduction operation to perform.
+/// num_devices: The number of devices participating in this reduction.
+/// shared_name: Identifier that shared between ops of the same reduction.
+@inlinable @inline(__always)
+public static func ncclAllReduce<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  reduction: Reduction,
+  numDevices: Int64,
+  sharedName: String
+) -> Tensor<T> {
+  let op = TFE_Op("NcclAllReduce")
+  op.setAttr("reduction", reduction.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("num_devices", numDevices)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Sends `input` to all devices that are connected to the output.
+///
+/// Sends `input` to all devices that are connected to the output.
+///
+/// The graph should be constructed so that all ops connected to the output have a
+/// valid device assignment, and the op itself is assigned one of these devices.
+///
+/// input: The input to the broadcast.
+/// output: The same as input.
+/// shape: The shape of the input tensor.
+///
+@inlinable @inline(__always)
+public static func ncclBroadcast<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  shape: TensorShape?
+) -> Tensor<T> {
+  let op = TFE_Op("NcclBroadcast")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("shape", shape)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Reduces `input` from `num_devices` using `reduction` to a single device.
+///
+/// Reduces `input` from `num_devices` using `reduction` to a single device.
+///
+/// The graph should be constructed so that all inputs have a valid device
+/// assignment, and the op itself is assigned one of these devices.
+///
+/// input: The input to the reduction.
+/// data: the value of the reduction across all `num_devices` devices.
+/// reduction: the reduction operation to perform.
+@inlinable @inline(__always)
+public static func ncclReduce<T: Numeric & TensorFlowScalar>(
+  _ input: [Tensor<T>],
+  reduction: Reduction
+) -> Tensor<T> {
+  let op = TFE_Op("NcclReduce")
+  op.setAttr("reduction", reduction.cName)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("num_devices", input.count)
+  let _ = op.addInputList(input)
+  return op.execute(Int(1))
+}
+
+/// Selects the k nearest centers for each point.
+///
+/// Rows of points are assumed to be input points. Rows of centers are assumed to be
+/// the list of candidate centers. For each point, the k centers that have least L2
+/// distance to it are computed.
+///
+/// - Parameters:
+///   - points: Matrix of shape (n, d). Rows are assumed to be input points.
+///   - centers: Matrix of shape (m, d). Rows are assumed to be centers.
+///   - k: Number of nearest centers to return for each point. If k is larger than m, then
+///     only m centers are returned.
+///
+/// - Outputs:
+///   - nearest_center_indices: Matrix of shape (n, min(m, k)). Each row contains the indices of the centers
+///     closest to the corresponding point, ordered by increasing distance.
+///   - nearest_center_distances: Matrix of shape (n, min(m, k)). Each row contains the squared L2 distance to the
+///     corresponding center in nearest_center_indices.
+@inlinable @inline(__always)
+public static func nearestNeighbors(
+  points: Tensor<Float>,
+  centers: Tensor<Float>,
+  k: Tensor<Int64>
+) -> (nearestCenterIndices: Tensor<Int64>, nearestCenterDistances: Tensor<Float>) {
+  let op = TFE_Op("NearestNeighbors")
+  let _ = op.addInput(points)
+  let _ = op.addInput(centers)
+  let _ = op.addInput(k)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Computes numerical negative value element-wise.
+///
+/// I.e., \\(y = -x\\).
+@inlinable @inline(__always)
+public static func neg<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Neg")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns the next representable value of `x1` in the direction of `x2`, element-wise.
+///
+/// This operation returns the same result as the C++ std::nextafter function.
+///
+/// It can also return a subnormal number.
+///
+/// @compatibility(cpp)
+/// Equivalent to C++ std::nextafter function.
+/// @end_compatibility
+@inlinable @inline(__always)
+public static func nextAfter<T: FloatingPoint & TensorFlowScalar>(
+  x1: Tensor<T>,
+  x2: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("NextAfter")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x1)
+  let _ = op.addInput(x2)
+  return op.execute(Int(1))
+}
+
+/// Makes its input available to the next iteration.
+///
+/// - Parameter data: The tensor to be made available to the next iteration.
+///
+/// - Output output: The same tensor as `data`.
+@inlinable @inline(__always)
+public static func nextIteration<T: TensorFlowScalar>(
+  data: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("NextIteration")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(data)
+  return op.execute(Int(1))
+}
+
+/// Does nothing. Only useful as a placeholder for control edges.
+@inlinable @inline(__always)
+public static func noOp(
+) {
+  let op = TFE_Op("NoOp")
+  
+  op.execute()
+}
+
+/// Non-deterministically generates some integers.
+///
+/// This op may use some OS-provided source of non-determinism (e.g. an RNG), so each execution will give different results.
+///
+/// - Parameter shape: The shape of the output tensor.
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Non-deterministic integer values with specified shape.
+@inlinable @inline(__always)
+public static func nonDeterministicInts<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+  shape: Tensor<ShapeDtype>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("NonDeterministicInts")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Greedily selects a subset of bounding boxes in descending order of score,
+///
+/// pruning away boxes that have high intersection-over-union (IOU) overlap
+/// with previously selected boxes.  Bounding boxes are supplied as
+/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+/// diagonal pair of box corners and the coordinates can be provided as normalized
+/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+/// is agnostic to where the origin is in the coordinate system.  Note that this
+/// algorithm is invariant to orthogonal transformations and translations
+/// of the coordinate system; thus translating or reflections of the coordinate
+/// system result in the same boxes being selected by the algorithm.
+/// The output of this operation is a set of integers indexing into the input
+/// collection of bounding boxes representing the selected boxes.  The bounding
+/// box coordinates corresponding to the selected indices can then be obtained
+/// using the `tf.gather operation`.  For example:
+///   selected_indices = tf.image.non_max_suppression(
+///       boxes, scores, max_output_size, iou_threshold)
+///   selected_boxes = tf.gather(boxes, selected_indices)
+///
+/// - Parameters:
+///   - boxes: A 2-D float tensor of shape `[num_boxes, 4]`.
+///   - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
+///     score corresponding to each box (each row of boxes).
+///   - max_output_size: A scalar integer tensor representing the maximum number of
+///     boxes to be selected by non max suppression.
+///
+/// - Attr iou_threshold: A float representing the threshold for deciding whether boxes
+///   overlap too much with respect to IOU.
+///
+/// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
+///   indices from the boxes tensor, where `M <= max_output_size`.
+@inlinable @inline(__always)
+public static func nonMaxSuppression(
+  boxes: Tensor<Float>,
+  scores: Tensor<Float>,
+  maxOutputSize: Tensor<Int32>,
+  iouThreshold: Double = 0.5
+) -> Tensor<Int32> {
+  let op = TFE_Op("NonMaxSuppression")
+  op.setAttr("iou_threshold", iouThreshold)
+  let _ = op.addInput(boxes)
+  let _ = op.addInput(scores)
+  let _ = op.addInput(maxOutputSize)
+  return op.execute(Int(1))
+}
+
+/// Greedily selects a subset of bounding boxes in descending order of score,
+///
+/// pruning away boxes that have high intersection-over-union (IOU) overlap
+/// with previously selected boxes.  Bounding boxes are supplied as
+/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+/// diagonal pair of box corners and the coordinates can be provided as normalized
+/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+/// is agnostic to where the origin is in the coordinate system.  Note that this
+/// algorithm is invariant to orthogonal transformations and translations
+/// of the coordinate system; thus translating or reflections of the coordinate
+/// system result in the same boxes being selected by the algorithm.
+///
+/// The output of this operation is a set of integers indexing into the input
+/// collection of bounding boxes representing the selected boxes.  The bounding
+/// box coordinates corresponding to the selected indices can then be obtained
+/// using the `tf.gather operation`.  For example:
+///
+///   selected_indices = tf.image.non_max_suppression_v2(
+///       boxes, scores, max_output_size, iou_threshold)
+///   selected_boxes = tf.gather(boxes, selected_indices)
+///
+/// - Parameters:
+///   - boxes: A 2-D float tensor of shape `[num_boxes, 4]`.
+///   - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
+///     score corresponding to each box (each row of boxes).
+///   - max_output_size: A scalar integer tensor representing the maximum number of
+///     boxes to be selected by non max suppression.
+///   - iou_threshold: A 0-D float tensor representing the threshold for deciding whether
+///     boxes overlap too much with respect to IOU.
+///
+/// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
+///   indices from the boxes tensor, where `M <= max_output_size`.
+@inlinable @inline(__always)
+public static func nonMaxSuppressionV2<T: FloatingPoint & TensorFlowScalar>(
+  boxes: Tensor<T>,
+  scores: Tensor<T>,
+  maxOutputSize: Tensor<Int32>,
+  iouThreshold: Tensor<Float>
+) -> Tensor<Int32> {
+  let op = TFE_Op("NonMaxSuppressionV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(boxes)
+  let _ = op.addInput(scores)
+  let _ = op.addInput(maxOutputSize)
+  let _ = op.addInput(iouThreshold)
+  return op.execute(Int(1))
+}
+
+/// Greedily selects a subset of bounding boxes in descending order of score,
+///
+/// pruning away boxes that have high intersection-over-union (IOU) overlap
+/// with previously selected boxes.  Bounding boxes with score less than
+/// `score_threshold` are removed.  Bounding boxes are supplied as
+/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+/// diagonal pair of box corners and the coordinates can be provided as normalized
+/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+/// is agnostic to where the origin is in the coordinate system and more
+/// generally is invariant to orthogonal transformations and translations
+/// of the coordinate system; thus translating or reflections of the coordinate
+/// system result in the same boxes being selected by the algorithm.
+/// The output of this operation is a set of integers indexing into the input
+/// collection of bounding boxes representing the selected boxes.  The bounding
+/// box coordinates corresponding to the selected indices can then be obtained
+/// using the `tf.gather operation`.  For example:
+///   selected_indices = tf.image.non_max_suppression_v2(
+///       boxes, scores, max_output_size, iou_threshold, score_threshold)
+///   selected_boxes = tf.gather(boxes, selected_indices)
+///
+/// - Parameters:
+///   - boxes: A 2-D float tensor of shape `[num_boxes, 4]`.
+///   - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
+///     score corresponding to each box (each row of boxes).
+///   - max_output_size: A scalar integer tensor representing the maximum number of
+///     boxes to be selected by non max suppression.
+///   - iou_threshold: A 0-D float tensor representing the threshold for deciding whether
+///     boxes overlap too much with respect to IOU.
+///   - score_threshold: A 0-D float tensor representing the threshold for deciding when to remove
+///     boxes based on score.
+///
+/// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
+///   indices from the boxes tensor, where `M <= max_output_size`.
+@inlinable @inline(__always)
+public static func nonMaxSuppressionV3<T: FloatingPoint & TensorFlowScalar>(
+  boxes: Tensor<T>,
+  scores: Tensor<T>,
+  maxOutputSize: Tensor<Int32>,
+  iouThreshold: Tensor<Float>,
+  scoreThreshold: Tensor<Float>
+) -> Tensor<Int32> {
+  let op = TFE_Op("NonMaxSuppressionV3")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(boxes)
+  let _ = op.addInput(scores)
+  let _ = op.addInput(maxOutputSize)
+  let _ = op.addInput(iouThreshold)
+  let _ = op.addInput(scoreThreshold)
+  return op.execute(Int(1))
+}
+
+/// Greedily selects a subset of bounding boxes in descending order of score,
+///
+/// pruning away boxes that have high intersection-over-union (IOU) overlap
+/// with previously selected boxes.  Bounding boxes with score less than
+/// `score_threshold` are removed.  Bounding boxes are supplied as
+/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+/// diagonal pair of box corners and the coordinates can be provided as normalized
+/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+/// is agnostic to where the origin is in the coordinate system and more
+/// generally is invariant to orthogonal transformations and translations
+/// of the coordinate system; thus translating or reflections of the coordinate
+/// system result in the same boxes being selected by the algorithm.
+/// The output of this operation is a set of integers indexing into the input
+/// collection of bounding boxes representing the selected boxes.  The bounding
+/// box coordinates corresponding to the selected indices can then be obtained
+/// using the `tf.gather operation`.  For example:
+///   selected_indices = tf.image.non_max_suppression_v2(
+///       boxes, scores, max_output_size, iou_threshold, score_threshold)
+///   selected_boxes = tf.gather(boxes, selected_indices)
+///
+/// - Parameters:
+///   - boxes: A 2-D float tensor of shape `[num_boxes, 4]`.
+///   - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
+///     score corresponding to each box (each row of boxes).
+///   - max_output_size: A scalar integer tensor representing the maximum number of
+///     boxes to be selected by non max suppression.
+///   - iou_threshold: A 0-D float tensor representing the threshold for deciding whether
+///     boxes overlap too much with respect to IOU.
+///   - score_threshold: A 0-D float tensor representing the threshold for deciding when to remove
+///     boxes based on score.
+///
+/// - Attr pad_to_max_output_size: If true, the output `selected_indices` is padded to be of length
+///   `max_output_size`. Defaults to false.
+///
+/// - Outputs:
+///   - selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
+///     indices from the boxes tensor, where `M <= max_output_size`.
+///   - valid_outputs: A 0-D integer tensor representing the number of valid elements in
+///     `selected_indices`, with the valid elements appearing first.
+@inlinable @inline(__always)
+public static func nonMaxSuppressionV4<T: FloatingPoint & TensorFlowScalar>(
+  boxes: Tensor<T>,
+  scores: Tensor<T>,
+  maxOutputSize: Tensor<Int32>,
+  iouThreshold: Tensor<Float>,
+  scoreThreshold: Tensor<Float>,
+  padToMaxOutputSize: Bool = false
+) -> (selectedIndices: Tensor<Int32>, validOutputs: Tensor<Int32>) {
+  let op = TFE_Op("NonMaxSuppressionV4")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("pad_to_max_output_size", padToMaxOutputSize)
+  let _ = op.addInput(boxes)
+  let _ = op.addInput(scores)
+  let _ = op.addInput(maxOutputSize)
+  let _ = op.addInput(iouThreshold)
+  let _ = op.addInput(scoreThreshold)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Greedily selects a subset of bounding boxes in descending order of score,
+///
+/// pruning away boxes that have high overlaps
+/// with previously selected boxes.  Bounding boxes with score less than
+/// `score_threshold` are removed. N-by-n overlap values are supplied as square matrix,
+/// which allows for defining a custom overlap criterium (eg. intersection over union,
+/// intersection over area, etc.).
+///
+/// The output of this operation is a set of integers indexing into the input
+/// collection of bounding boxes representing the selected boxes.  The bounding
+/// box coordinates corresponding to the selected indices can then be obtained
+/// using the `tf.gather operation`.  For example:
+///
+///   selected_indices = tf.image.non_max_suppression_with_overlaps(
+///       overlaps, scores, max_output_size, overlap_threshold, score_threshold)
+///   selected_boxes = tf.gather(boxes, selected_indices)
+///
+/// - Parameters:
+///   - overlaps: A 2-D float tensor of shape `[num_boxes, num_boxes]` representing
+///     the n-by-n box overlap values.
+///   - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
+///     score corresponding to each box (each row of boxes).
+///   - max_output_size: A scalar integer tensor representing the maximum number of
+///     boxes to be selected by non max suppression.
+///   - overlap_threshold: A 0-D float tensor representing the threshold for deciding whether
+///     boxes overlap too.
+///   - score_threshold: A 0-D float tensor representing the threshold for deciding when to remove
+///     boxes based on score.
+///
+/// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
+///   indices from the boxes tensor, where `M <= max_output_size`.
+@inlinable @inline(__always)
+public static func nonMaxSuppressionWithOverlaps(
+  overlaps: Tensor<Float>,
+  scores: Tensor<Float>,
+  maxOutputSize: Tensor<Int32>,
+  overlapThreshold: Tensor<Float>,
+  scoreThreshold: Tensor<Float>
+) -> Tensor<Int32> {
+  let op = TFE_Op("NonMaxSuppressionWithOverlaps")
+  let _ = op.addInput(overlaps)
+  let _ = op.addInput(scores)
+  let _ = op.addInput(maxOutputSize)
+  let _ = op.addInput(overlapThreshold)
+  let _ = op.addInput(scoreThreshold)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func none(
+) {
+  let op = TFE_Op("None")
+  
+  op.execute()
+}
+
+/// Returns the truth value of (x != y) element-wise.
+///
+/// *NOTE*: `NotEqual` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func notEqual<T: TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<Bool> {
+  let op = TFE_Op("NotEqual")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x != y) element-wise.
+///
+/// *NOTE*: `NotEqual` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func notEqual(
+  _ x: StringTensor,
+  _ y: StringTensor
+) -> Tensor<Bool> {
+  let op = TFE_Op("NotEqual")
+  op.setAttr("T", TensorDataType(TF_STRING))
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Finds values of the `n`-th order statistic for the last dimension.
+///
+/// If the input is a vector (rank-1), finds the entries which is the nth-smallest
+/// value in the vector and outputs their values as scalar tensor.
+///
+/// For matrices (resp. higher rank input), computes the entries which is the
+/// nth-smallest value in each row (resp. vector along the last dimension). Thus,
+///
+///     values.shape = input.shape[:-1]
+///
+/// - Parameters:
+///   - input: 1-D or higher with last dimension at least `n+1`.
+///   - n: 0-D. Position of sorted vector to select along the last dimension (along
+///     each row for matrices). Valid range of n is `[0, input.shape[:-1])`
+///
+/// - Attr reverse: When set to True, find the nth-largest value in the vector and vice
+///   versa.
+///
+/// - Output values: The `n`-th order statistic along each last dimensional slice.
+@inlinable @inline(__always)
+public static func nthElement<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  n: Tensor<Int32>,
+  reverse: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("NthElement")
+  op.setAttr("reverse", reverse)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(n)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func old(
+) {
+  let op = TFE_Op("Old")
+  
+  op.execute()
+}
+
+/// Returns a one-hot tensor.
+///
+/// The locations represented by indices in `indices` take value `on_value`,
+/// while all other locations take value `off_value`.
+///
+/// If the input `indices` is rank `N`, the output will have rank `N+1`,
+/// The new axis is created at dimension `axis` (default: the new axis is
+/// appended at the end).
+///
+/// If `indices` is a scalar the output shape will be a vector of length `depth`.
+///
+/// If `indices` is a vector of length `features`, the output shape will be:
+/// ```
+///   features x depth if axis == -1
+///   depth x features if axis == 0
+/// ```
+///
+/// If `indices` is a matrix (batch) with shape `[batch, features]`,
+/// the output shape will be:
+/// ```
+///   batch x features x depth if axis == -1
+///   batch x depth x features if axis == 1
+///   depth x batch x features if axis == 0
+/// ```
+///
+///
+/// Examples
+/// =========
+///
+/// Suppose that
+/// ```
+///   indices = [0, 2, -1, 1]
+///   depth = 3
+///   on_value = 5.0
+///   off_value = 0.0
+///   axis = -1
+/// ```
+///
+/// Then output is `[4 x 3]`:
+/// ```
+/// output =
+///   [5.0 0.0 0.0]  // one_hot(0)
+///   [0.0 0.0 5.0]  // one_hot(2)
+///   [0.0 0.0 0.0]  // one_hot(-1)
+///   [0.0 5.0 0.0]  // one_hot(1)
+/// ```
+///
+/// Suppose that
+/// ```
+///   indices = [0, 2, -1, 1]
+///   depth = 3
+///   on_value = 0.0
+///   off_value = 3.0
+///   axis = 0
+/// ```
+///
+/// Then output is `[3 x 4]`:
+/// ```
+/// output =
+///   [0.0 3.0 3.0 3.0]
+///   [3.0 3.0 3.0 0.0]
+///   [3.0 3.0 3.0 3.0]
+///   [3.0 0.0 3.0 3.0]
+/// //  ^                one_hot(0)
+/// //      ^            one_hot(2)
+/// //          ^        one_hot(-1)
+/// //              ^    one_hot(1)
+/// ```
+///
+/// Suppose that
+/// ```
+///   indices = [[0, 2], [1, -1]]
+///   depth = 3
+///   on_value = 1.0
+///   off_value = 0.0
+///   axis = -1
+/// ```
+///
+/// Then output is `[2 x 2 x 3]`:
+/// ```
+/// output =
+///   [
+///     [1.0, 0.0, 0.0]  // one_hot(0)
+///     [0.0, 0.0, 1.0]  // one_hot(2)
+///   ][
+///     [0.0, 1.0, 0.0]  // one_hot(1)
+///     [0.0, 0.0, 0.0]  // one_hot(-1)
+///   ]
+/// ```
+///
+/// - Parameters:
+///   - indices: A tensor of indices.
+///   - depth: A scalar defining the depth of the one hot dimension.
+///   - on_value: A scalar defining the value to fill in output when `indices[j] = i`.
+///   - off_value: A scalar defining the value to fill in output when `indices[j] != i`.
+///
+/// - Attr axis: The axis to fill (default: -1, a new inner-most axis).
+///
+/// - Output output: The one-hot tensor.
+@inlinable @inline(__always)
+public static func oneHot<
+    T: TensorFlowScalar,
+    Ti: BinaryInteger & TensorFlowScalar
+>(
+  indices: Tensor<Ti>,
+  depth: Tensor<Int32>,
+  onValue: Tensor<T>,
+  offValue: Tensor<T>,
+  axis: Int64 = -1
+) -> Tensor<T> {
+  let op = TFE_Op("OneHot")
+  op.setAttr("axis", axis)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("TI", Ti.tensorFlowDataType)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(depth)
+  let _ = op.addInput(onValue)
+  let _ = op.addInput(offValue)
+  return op.execute(Int(1))
+}
+
+/// Makes a "one-shot" iterator that can be iterated only once.
+///
+/// A one-shot iterator bundles the logic for defining the dataset and
+/// the state of the iterator in a single op, which allows simple input
+/// pipelines to be defined without an additional initialization
+/// ("MakeIterator") step.
+///
+/// One-shot iterators have the following limitations:
+///
+/// * They do not support parameterization: all logic for creating the underlying
+///   dataset must be bundled in the `dataset_factory` function.
+/// * They are not resettable. Once a one-shot iterator reaches the end of its
+///   underlying dataset, subsequent "IteratorGetNext" operations on that
+///   iterator will always produce an `OutOfRange` error.
+///
+/// For greater flexibility, use "Iterator" and "MakeIterator" to define
+/// an iterator using an arbitrary subgraph, which may capture tensors
+/// (including fed values) as parameters, and which may be reset multiple
+/// times by rerunning "MakeIterator".
+///
+/// - Attr dataset_factory: A function of type `() -> DT_VARIANT`, where the returned
+///   DT_VARIANT is a dataset.
+///
+/// - Output handle: A handle to the iterator that can be passed to an "IteratorGetNext"
+///   op.
+@inlinable @inline(__always)
+public static func oneShotIterator<DatasetfactoryIn: TensorGroup,
+    DatasetfactoryOut: TensorGroup>(
+  datasetFactory: (DatasetfactoryIn) -> DatasetfactoryOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?],
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("OneShotIterator")
+  op.setAttr("dataset_factory", datasetFactory)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Returns a tensor of ones with the same shape and type as x.
+///
+/// - Parameter x: a tensor of type T.
+///
+/// - Output y: a tensor of the same shape and type as x but filled with ones.
+@inlinable @inline(__always)
+public static func onesLike<T: TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("OnesLike")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func opWithDefaultAttr(
+  defaultFloat: Double = 123
+) -> Tensor<Int32> {
+  let op = TFE_Op("OpWithDefaultAttr")
+  op.setAttr("default_float", defaultFloat)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func opWithFutureDefaultAttr(
+) {
+  let op = TFE_Op("OpWithFutureDefaultAttr")
+  
+  op.execute()
+}
+
+/// Creates a dataset by applying optimizations to `input_dataset`.
+///
+/// Creates a dataset by applying optimizations to `input_dataset`.
+///
+/// - Parameters:
+///   - input_dataset: A variant tensor representing the input dataset.
+///   - optimizations: A `tf.string` vector `tf.Tensor` identifying optimizations to use.
+@inlinable @inline(__always)
+public static func optimizeDataset(
+  inputDataset: VariantHandle,
+  optimizations: StringTensor,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?],
+  optimizationConfigs: [String]
+) -> VariantHandle {
+  let op = TFE_Op("OptimizeDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("optimization_configs", optimizationConfigs)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(optimizations)
+  return op.execute(Int(1))
+}
+
+/// Constructs an Optional variant from a tuple of tensors.
+@inlinable @inline(__always)
+public static func optionalFromValue<ToutputTypes: TensorArrayProtocol>(
+  components: ToutputTypes
+) -> VariantHandle {
+  let op = TFE_Op("OptionalFromValue")
+  op.setAttr("Toutput_types", components._typeList)
+  let _ = op.addInputList(components)
+  return op.execute(Int(1))
+}
+
+/// Returns the value stored in an Optional variant or raises an error if none exists.
+@inlinable @inline(__always)
+public static func optionalGetValue<OutputTypes: TensorGroup>(
+  optional: VariantHandle,
+  outputShapes: [TensorShape?]
+) -> OutputTypes {
+  let op = TFE_Op("OptionalGetValue")
+  op.setAttr("output_types", OutputTypes._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(optional)
+  return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Returns true if and only if the given Optional variant has a value.
+@inlinable @inline(__always)
+public static func optionalHasValue(
+  optional: VariantHandle
+) -> Tensor<Bool> {
+  let op = TFE_Op("OptionalHasValue")
+  let _ = op.addInput(optional)
+  return op.execute(Int(1))
+}
+
+/// Creates an Optional variant with no value.
+@inlinable @inline(__always)
+public static func optionalNone(
+) -> VariantHandle {
+  let op = TFE_Op("OptionalNone")
+  
+  return op.execute(Int(1))
+}
+
+/// Op removes all elements in the underlying container.
+@inlinable @inline(__always)
+public static func orderedMapClear(
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  dtypes: [TensorDataType],
+  container: String,
+  sharedName: String
+) {
+  let op = TFE_Op("OrderedMapClear")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", dtypes)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.execute()
+}
+
+/// Op returns the number of incomplete elements in the underlying container.
+@inlinable @inline(__always)
+public static func orderedMapIncompleteSize(
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  dtypes: [TensorDataType],
+  container: String,
+  sharedName: String
+) -> Tensor<Int32> {
+  let op = TFE_Op("OrderedMapIncompleteSize")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", dtypes)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Op peeks at the values at the specified key.  If the
+///
+/// underlying container does not contain this key
+/// this op will block until it does.   This Op is optimized for
+/// performance.
+@inlinable @inline(__always)
+public static func orderedMapPeek<Dtypes: TensorGroup>(
+  key: Tensor<Int64>,
+  indices: Tensor<Int32>,
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  container: String,
+  sharedName: String
+) -> Dtypes {
+  let op = TFE_Op("OrderedMapPeek")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", Dtypes._typeList)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(key)
+  let _ = op.addInput(indices)
+  return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// Op returns the number of elements in the underlying container.
+@inlinable @inline(__always)
+public static func orderedMapSize(
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  dtypes: [TensorDataType],
+  container: String,
+  sharedName: String
+) -> Tensor<Int32> {
+  let op = TFE_Op("OrderedMapSize")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", dtypes)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Stage (key, values) in the underlying container which behaves like a ordered
+///
+/// associative container.   Elements are ordered by key.
+///
+/// - Parameters:
+///   - key: int64
+///   - values: a list of tensors
+///     dtypes A list of data types that inserted values should adhere to.
+///
+/// - Attrs:
+///   - capacity: Maximum number of elements in the Staging Area. If > 0, inserts
+///     on the container will block when the capacity is reached.
+///   - container: If non-empty, this queue is placed in the given container. Otherwise,
+///     a default container is used.
+///   - shared_name: It is necessary to match this name to the matching Unstage Op.
+@inlinable @inline(__always)
+public static func orderedMapStage<FakeDtypes: TensorArrayProtocol>(
+  key: Tensor<Int64>,
+  indices: Tensor<Int32>,
+  _ values: FakeDtypes,
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  dtypes: [TensorDataType],
+  container: String,
+  sharedName: String
+) {
+  let op = TFE_Op("OrderedMapStage")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", dtypes)
+  op.setAttr("fake_dtypes", values._typeList)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(key)
+  let _ = op.addInput(indices)
+  let _ = op.addInputList(values)
+  op.execute()
+}
+
+/// Op removes and returns the values associated with the key
+///
+/// from the underlying container.   If the underlying container
+/// does not contain this key, the op will block until it does.
+@inlinable @inline(__always)
+public static func orderedMapUnstage<Dtypes: TensorGroup>(
+  key: Tensor<Int64>,
+  indices: Tensor<Int32>,
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  container: String,
+  sharedName: String
+) -> Dtypes {
+  let op = TFE_Op("OrderedMapUnstage")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", Dtypes._typeList)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(key)
+  let _ = op.addInput(indices)
+  return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// Op removes and returns the (key, value) element with the smallest
+///
+/// key from the underlying container.   If the underlying container
+/// does not contain elements, the op will block until it does.
+@inlinable @inline(__always)
+public static func orderedMapUnstageNoKey<Dtypes: TensorGroup>(
+  indices: Tensor<Int32>,
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  container: String,
+  sharedName: String
+) -> (key: Tensor<Int64>, values: Dtypes) {
+  let op = TFE_Op("OrderedMapUnstageNoKey")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", Dtypes._typeList)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(indices)
+  return op.execute(Int(1), Int(Dtypes._typeList.count))
+}
+
+@inlinable @inline(__always)
+public static func outT<T: TensorFlowScalar>(
+) -> Tensor<T> {
+  let op = TFE_Op("OutT")
+  op.setAttr("T", T.tensorFlowDataType)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func outTypeList<T: TensorGroup>(
+) -> T {
+  let op = TFE_Op("OutTypeList")
+  op.setAttr("T", T._typeList)
+  return op.execute(Int(T._typeList.count))
+}
+
+@inlinable @inline(__always)
+public static func outTypeListRestrict<T: TensorGroup>(
+) -> T {
+  let op = TFE_Op("OutTypeListRestrict")
+  op.setAttr("t", T._typeList)
+  return op.execute(Int(T._typeList.count))
+}
+
+/// Retrieves a single tensor from the computation outfeed.
+///
+/// This operation will block indefinitely until data is available.
+///
+/// - Attrs:
+///   - dtype: The type of elements in the tensor.
+///   - shape: The shape of the tensor.
+///   - device_ordinal: The TPU device to use. This should be -1 when the Op
+///     is running on a TPU device, and >= 0 when the Op is running on the CPU
+///     device.
+///
+/// - Output output: A tensor that will be read from the device outfeed.
+@inlinable @inline(__always)
+public static func outfeedDequeue<Dtype: TensorFlowScalar>(
+  shape: TensorShape?,
+  deviceOrdinal: Int64 = -1
+) -> Tensor<Dtype> {
+  let op = TFE_Op("OutfeedDequeue")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape", shape)
+  op.setAttr("device_ordinal", deviceOrdinal)
+  return op.execute(Int(1))
+}
+
+/// Retrieve multiple values from the computation outfeed.
+///
+/// This operation will block indefinitely until data is available. Output `i`
+/// corresponds to XLA tuple element `i`.
+///
+/// - Attrs:
+///   - dtypes: The element types of each element in `outputs`.
+///   - shapes: The shapes of each tensor in `outputs`.
+///   - device_ordinal: The TPU device to use. This should be -1 when the Op
+///     is running on a TPU device, and >= 0 when the Op is running on the CPU
+///     device.
+///
+/// - Output outputs: A list of tensors that will be read from the outfeed.
+@inlinable @inline(__always)
+public static func outfeedDequeueTuple<Dtypes: TensorGroup>(
+  shapes: [TensorShape?],
+  deviceOrdinal: Int64 = -1
+) -> Dtypes {
+  let op = TFE_Op("OutfeedDequeueTuple")
+  op.setAttr("dtypes", Dtypes._typeList)
+  op.setAttr("shapes", shapes)
+  op.setAttr("device_ordinal", deviceOrdinal)
+  return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// Enqueue a Tensor on the computation outfeed.
+///
+/// - Parameter input: A tensor that will be inserted into the outfeed queue.
+@inlinable @inline(__always)
+public static func outfeedEnqueue<Dtype: TensorFlowScalar>(
+  _ input: Tensor<Dtype>
+) {
+  let op = TFE_Op("OutfeedEnqueue")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(input)
+  op.execute()
+}
+
+/// Enqueue multiple Tensor values on the computation outfeed.
+///
+/// - Parameter inputs: A list of tensors that will be inserted into the outfeed queue as an
+///   XLA tuple.
+@inlinable @inline(__always)
+public static func outfeedEnqueueTuple<Dtypes: TensorArrayProtocol>(
+  inputs: Dtypes
+) {
+  let op = TFE_Op("OutfeedEnqueueTuple")
+  op.setAttr("dtypes", inputs._typeList)
+  let _ = op.addInputList(inputs)
+  op.execute()
+}
+
+/// Packs a list of `N` rank-`R` tensors into one rank-`(R+1)` tensor.
+///
+/// Packs the `N` tensors in `values` into a tensor with rank one higher than each
+/// tensor in `values`, by packing them along the `axis` dimension.
+/// Given a list of tensors of shape `(A, B, C)`;
+///
+/// if `axis == 0` then the `output` tensor will have the shape `(N, A, B, C)`.
+/// if `axis == 1` then the `output` tensor will have the shape `(A, N, B, C)`.
+/// Etc.
+///
+/// For example:
+///
+/// ```
+/// # 'x' is [1, 4]
+/// # 'y' is [2, 5]
+/// # 'z' is [3, 6]
+/// pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
+/// pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]]
+/// ```
+///
+/// This is the opposite of `unpack`.
+///
+/// - Parameter values: Must be of same shape and type.
+///
+/// - Attr axis: Dimension along which to pack.  Negative values wrap around, so the
+///   valid range is `[-(R+1), R+1)`.
+///
+/// - Output output: The packed tensor.
+@inlinable @inline(__always)
+public static func pack<T: TensorFlowScalar>(
+  _ values: [Tensor<T>],
+  axis: Int64 = 0
+) -> Tensor<T> {
+  let op = TFE_Op("Pack")
+  op.setAttr("N", values.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("axis", axis)
+  let _ = op.addInputList(values)
+  return op.execute(Int(1))
+}
+
+/// Pads a tensor with zeros.
+///
+/// This operation pads a `input` with zeros according to the `paddings` you
+/// specify. `paddings` is an integer tensor with shape `[Dn, 2]`, where n is the
+/// rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
+/// how many zeros to add before the contents of `input` in that dimension, and
+/// `paddings[D, 1]` indicates how many zeros to add after the contents of `input`
+/// in that dimension.
+///
+/// The padded size of each dimension D of the output is:
+///
+/// `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[1, 1], [2, 2]]
+/// # 'paddings' is [[1, 1], [2, 2]]
+/// # rank of 't' is 2
+/// pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
+///                       [0, 0, 1, 1, 0, 0]
+///                       [0, 0, 2, 2, 0, 0]
+///                       [0, 0, 0, 0, 0, 0]]
+/// ```
+///
+@inlinable @inline(__always)
+public static func pad<
+    T: TensorFlowScalar,
+    Tpaddings: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  paddings: Tensor<Tpaddings>
+) -> Tensor<T> {
+  let op = TFE_Op("Pad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tpaddings", Tpaddings.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(paddings)
+  return op.execute(Int(1))
+}
+
+/// Pads a tensor.
+///
+/// This operation pads `input` according to the `paddings` and `constant_values`
+/// you specify. `paddings` is an integer tensor with shape `[Dn, 2]`, where n is
+/// the rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
+/// how many padding values to add before the contents of `input` in that dimension,
+/// and `paddings[D, 1]` indicates how many padding values to add after the contents
+/// of `input` in that dimension. `constant_values` is a scalar tensor of the same
+/// type as `input` that indicates the value to use for padding `input`.
+///
+/// The padded size of each dimension D of the output is:
+///
+/// `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[1, 1], [2, 2]]
+/// # 'paddings' is [[1, 1], [2, 2]]
+/// # 'constant_values' is 0
+/// # rank of 't' is 2
+/// pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
+///                       [0, 0, 1, 1, 0, 0]
+///                       [0, 0, 2, 2, 0, 0]
+///                       [0, 0, 0, 0, 0, 0]]
+/// ```
+@inlinable @inline(__always)
+public static func padV2<
+    T: TensorFlowScalar,
+    Tpaddings: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  paddings: Tensor<Tpaddings>,
+  constantValues: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("PadV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tpaddings", Tpaddings.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(paddings)
+  let _ = op.addInput(constantValues)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that batches and pads `batch_size` elements from the input.
+///
+/// - Parameters:
+///   - batch_size: A scalar representing the number of elements to accumulate in a
+///     batch.
+///   - padded_shapes: A list of int64 tensors representing the desired padded shapes
+///     of the corresponding output components. These shapes may be partially
+///     specified, using `-1` to indicate that a particular dimension should be
+///     padded to the maximum size of all batch elements.
+///   - padding_values: A list of scalars containing the padding value to use for
+///     each of the outputs.
+@inlinable @inline(__always)
+public static func paddedBatchDataset<ToutputTypes: TensorArrayProtocol>(
+  inputDataset: VariantHandle,
+  batchSize: Tensor<Int64>,
+  paddedShapes: [Tensor<Int64>],
+  paddingValues: ToutputTypes,
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("PaddedBatchDataset")
+  op.setAttr("Toutput_types", paddingValues._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("N", paddedShapes.count)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(batchSize)
+  let _ = op.addInputList(paddedShapes)
+  let _ = op.addInputList(paddingValues)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that batches and pads `batch_size` elements from the input.
+///
+/// - Parameters:
+///   - batch_size: A scalar representing the number of elements to accumulate in a
+///     batch.
+///   - padded_shapes: A list of int64 tensors representing the desired padded shapes
+///     of the corresponding output components. These shapes may be partially
+///     specified, using `-1` to indicate that a particular dimension should be
+///     padded to the maximum size of all batch elements.
+///   - padding_values: A list of scalars containing the padding value to use for
+///     each of the outputs.
+///   - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
+///     is smaller than desired.
+@inlinable @inline(__always)
+public static func paddedBatchDatasetV2<ToutputTypes: TensorArrayProtocol>(
+  inputDataset: VariantHandle,
+  batchSize: Tensor<Int64>,
+  paddedShapes: [Tensor<Int64>],
+  paddingValues: ToutputTypes,
+  dropRemainder: Tensor<Bool>,
+  parallelCopy: Bool = false,
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("PaddedBatchDatasetV2")
+  op.setAttr("parallel_copy", parallelCopy)
+  op.setAttr("Toutput_types", paddingValues._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("N", paddedShapes.count)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(batchSize)
+  let _ = op.addInputList(paddedShapes)
+  let _ = op.addInputList(paddingValues)
+  let _ = op.addInput(dropRemainder)
+  return op.execute(Int(1))
+}
+
+/// A queue that produces elements in first-in first-out order.
+///
+/// Variable-size shapes are allowed by setting the corresponding shape dimensions
+/// to 0 in the shape attr.  In this case DequeueMany will pad up to the maximum
+/// size of any given element in the minibatch.  See below for details.
+///
+/// - Attrs:
+///   - component_types: The type of each component in a value.
+///   - shapes: The shape of each component in a value. The length of this attr must
+///     be either 0 or the same as the length of component_types.
+///     Shapes of fixed rank but variable size are allowed by setting
+///     any shape dimension to -1.  In this case, the inputs' shape may vary along
+///     the given dimension, and DequeueMany will pad the given dimension with
+///     zeros up to the maximum shape of all elements in the given batch.
+///     If the length of this attr is 0, different queue elements may have
+///     different ranks and shapes, but only one element may be dequeued at a time.
+///   - capacity: The upper bound on the number of elements in this queue.
+///     Negative numbers mean no limit.
+///   - container: If non-empty, this queue is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this queue will be shared under the given name
+///     across multiple sessions.
+///
+/// - Output handle: The handle to the queue.
+@inlinable @inline(__always)
+public static func paddingFIFOQueueV2(
+  componentTypes: [TensorDataType],
+  shapes: [TensorShape?],
+  capacity: Int64 = -1,
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("PaddingFIFOQueueV2")
+  op.setAttr("component_types", componentTypes)
+  op.setAttr("shapes", shapes)
+  op.setAttr("capacity", capacity)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Concatenates a list of `N` tensors along the first dimension.
+///
+/// The input tensors are all required to have size 1 in the first dimension.
+///
+/// For example:
+///
+/// ```
+/// # 'x' is [[1, 4]]
+/// # 'y' is [[2, 5]]
+/// # 'z' is [[3, 6]]
+/// parallel_concat([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
+/// ```
+///
+/// The difference between concat and parallel_concat is that concat requires all
+/// of the inputs be computed before the operation will begin but doesn't require
+/// that the input shapes be known during graph construction.  Parallel concat
+/// will copy pieces of the input into the output as they become available, in
+/// some situations this can provide a performance benefit.
+///
+/// - Parameter values: Tensors to be concatenated. All must have size 1 in the first dimension
+///   and same shape.
+///
+/// - Attr shape: the final shape of the result; should be equal to the shapes of any input
+///   but with the number of input values in the first dimension.
+///
+/// - Output output: The concatenated tensor.
+@inlinable @inline(__always)
+public static func parallelConcat<T: TensorFlowScalar>(
+  _ values: [Tensor<T>],
+  shape: TensorShape?
+) -> Tensor<T> {
+  let op = TFE_Op("ParallelConcat")
+  op.setAttr("N", values.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("shape", shape)
+  let _ = op.addInputList(values)
+  return op.execute(Int(1))
+}
+
+/// Interleave the values from the `data` tensors into a single tensor.
+///
+/// Builds a merged tensor such that
+///
+/// ```python
+///     merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
+/// ```
+///
+/// For example, if each `indices[m]` is scalar or vector, we have
+///
+/// ```python
+///     # Scalar indices:
+///     merged[indices[m], ...] = data[m][...]
+///
+///     # Vector indices:
+///     merged[indices[m][i], ...] = data[m][i, ...]
+/// ```
+///
+/// Each `data[i].shape` must start with the corresponding `indices[i].shape`,
+/// and the rest of `data[i].shape` must be constant w.r.t. `i`.  That is, we
+/// must have `data[i].shape = indices[i].shape + constant`.  In terms of this
+/// `constant`, the output shape is
+///
+///     merged.shape = [max(indices)] + constant
+///
+/// Values may be merged in parallel, so if an index appears in both `indices[m][i]`
+/// and `indices[n][j]`, the result may be invalid. This differs from the normal
+/// DynamicStitch operator that defines the behavior in that case.
+///
+/// For example:
+///
+/// ```python
+///     indices[0] = 6
+///     indices[1] = [4, 1]
+///     indices[2] = [[5, 2], [0, 3]]
+///     data[0] = [61, 62]
+///     data[1] = [[41, 42], [11, 12]]
+///     data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
+///     merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
+///               [51, 52], [61, 62]]
+/// ```
+///
+/// This method can be used to merge partitions created by `dynamic_partition`
+/// as illustrated on the following example:
+///
+/// ```python
+///     # Apply function (increments x_i) on elements for which a certain condition
+///     # apply (x_i != -1 in this example).
+///     x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
+///     condition_mask=tf.not_equal(x,tf.constant(-1.))
+///     partitioned_data = tf.dynamic_partition(
+///         x, tf.cast(condition_mask, tf.int32) , 2)
+///     partitioned_data[1] = partitioned_data[1] + 1.0
+///     condition_indices = tf.dynamic_partition(
+///         tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
+///     x = tf.dynamic_stitch(condition_indices, partitioned_data)
+///     # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
+///     # unchanged.
+/// ```
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/DynamicStitch.png" alt>
+/// </div>
+@inlinable @inline(__always)
+public static func parallelDynamicStitch<T: TensorFlowScalar>(
+  indices: [Tensor<Int32>],
+  data: [Tensor<T>]
+) -> Tensor<T> {
+  let op = TFE_Op("ParallelDynamicStitch")
+  op.setAttr("N", indices.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInputList(indices)
+  let _ = op.addInputList(data)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+///
+/// - Attr f: A function mapping elements of `input_dataset`, concatenated with
+///   `other_arguments`, to a Dataset variant that contains elements matching
+///   `output_types` and `output_shapes`.
+@inlinable @inline(__always)
+public static func parallelInterleaveDatasetV2<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  otherArguments: Targuments,
+  cycleLength: Tensor<Int64>,
+  blockLength: Tensor<Int64>,
+  numParallelCalls: Tensor<Int64>,
+  f: (FIn) -> FOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?],
+  sloppy: Bool = false
+) -> VariantHandle {
+  let op = TFE_Op("ParallelInterleaveDatasetV2")
+  op.setAttr("f", f)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("sloppy", sloppy)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(otherArguments)
+  let _ = op.addInput(cycleLength)
+  let _ = op.addInput(blockLength)
+  let _ = op.addInput(numParallelCalls)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+///
+/// Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
+/// to `num_parallel_calls` copies of `f` in parallel.
+///
+/// - Parameter num_parallel_calls: The number of concurrent invocations of `f` that process
+///   elements from `input_dataset` in parallel.
+@inlinable @inline(__always)
+public static func parallelMapDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+  inputDataset: VariantHandle,
+  otherArguments: Targuments,
+  numParallelCalls: Tensor<Int32>,
+  f: (FIn) -> FOut,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?],
+  useInterOpParallelism: Bool = true,
+  sloppy: Bool = false,
+  preserveCardinality: Bool = false
+) -> VariantHandle {
+  let op = TFE_Op("ParallelMapDataset")
+  op.setAttr("f", f)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("use_inter_op_parallelism", useInterOpParallelism)
+  op.setAttr("sloppy", sloppy)
+  op.setAttr("preserve_cardinality", preserveCardinality)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(otherArguments)
+  let _ = op.addInput(numParallelCalls)
+  return op.execute(Int(1))
+}
+
+/// Outputs random values from a normal distribution. The parameters may each be a
+///
+/// scalar which applies to the entire output, or a vector of length shape[0] which
+/// stores the parameters for each batch.
+///
+/// - Parameters:
+///   - shape: The shape of the output tensor. Batches are indexed by the 0th dimension.
+///   - means: The mean parameter of each batch.
+///   - stdevs: The standard deviation parameter of each batch. Must be greater than 0.
+///   - minvals: The minimum cutoff. May be -infinity.
+///   - maxvals: The maximum cutoff. May be +infinity, and must be more than the minval
+///     for each batch.
+///
+/// - Attrs:
+///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: A second seed to avoid seed collision.
+///   - dtype: The type of the output.
+///
+/// - Output output: A matrix of shape num_batches x samples_per_batch, filled with random
+///   truncated normal values using the parameters for each row.
+@inlinable @inline(__always)
+public static func parameterizedTruncatedNormal<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar
+>(
+  shape: Tensor<T>,
+  means: Tensor<Dtype>,
+  stdevs: Tensor<Dtype>,
+  minvals: Tensor<Dtype>,
+  maxvals: Tensor<Dtype>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<Dtype> {
+  let op = TFE_Op("ParameterizedTruncatedNormal")
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(means)
+  let _ = op.addInput(stdevs)
+  let _ = op.addInput(minvals)
+  let _ = op.addInput(maxvals)
+  return op.execute(Int(1))
+}
+
+/// Transforms a vector of brain.Example protos (as strings) into typed tensors.
+///
+/// - Parameters:
+///   - serialized: A vector containing a batch of binary serialized Example protos.
+///   - names: A vector containing the names of the serialized protos.
+///     May contain, for example, table key (descriptive) names for the
+///     corresponding serialized protos.  These are purely useful for debugging
+///     purposes, and the presence of values here has no effect on the output.
+///     May also be an empty vector if no names are available.
+///     If non-empty, this vector must be the same length as "serialized".
+///   - sparse_keys: A list of Nsparse string Tensors (scalars).
+///     The keys expected in the Examples' features associated with sparse values.
+///   - dense_keys: A list of Ndense string Tensors (scalars).
+///     The keys expected in the Examples' features associated with dense values.
+///   - dense_defaults: A list of Ndense Tensors (some may be empty).
+///     dense_defaults[j] provides default values
+///     when the example's feature_map lacks dense_key[j].  If an empty Tensor is
+///     provided for dense_defaults[j], then the Feature dense_keys[j] is required.
+///     The input type is inferred from dense_defaults[j], even when it's empty.
+///     If dense_defaults[j] is not empty, and dense_shapes[j] is fully defined,
+///     then the shape of dense_defaults[j] must match that of dense_shapes[j].
+///     If dense_shapes[j] has an undefined major dimension (variable strides dense
+///     feature), dense_defaults[j] must contain a single element:
+///     the padding element.
+///
+/// - Attrs:
+///   - sparse_types: A list of Nsparse types; the data types of data in each Feature
+///     given in sparse_keys.
+///     Currently the ParseExample supports DT_FLOAT (FloatList),
+///     DT_INT64 (Int64List), and DT_STRING (BytesList).
+///   - dense_shapes: A list of Ndense shapes; the shapes of data in each Feature
+///     given in dense_keys.
+///     The number of elements in the Feature corresponding to dense_key[j]
+///     must always equal dense_shapes[j].NumEntries().
+///     If dense_shapes[j] == (D0, D1, ..., DN) then the shape of output
+///     Tensor dense_values[j] will be (|serialized|, D0, D1, ..., DN):
+///     The dense outputs are just the inputs row-stacked by batch.
+///     This works for dense_shapes[j] = (-1, D1, ..., DN).  In this case
+///     the shape of the output Tensor dense_values[j] will be
+///     (|serialized|, M, D1, .., DN), where M is the maximum number of blocks
+///     of elements of length D1 * .... * DN, across all minibatch entries
+///     in the input.  Any minibatch entry with less than M blocks of elements of
+///     length D1 * ... * DN will be padded with the corresponding default_value
+///     scalar element along the second dimension.
+@inlinable @inline(__always)
+public static func parseExample<
+    SparseTypes: TensorGroup,
+    Tdense: TensorArrayProtocol
+>(
+  serialized: StringTensor,
+  names: StringTensor,
+  sparseKeys: [StringTensor],
+  denseKeys: [StringTensor],
+  denseDefaults: Tdense,
+  denseShapes: [TensorShape?]
+) -> (sparseIndices: [Tensor<Int64>], sparseValues: SparseTypes, sparseShapes: [Tensor<Int64>], denseValues: Tdense) {
+  let op = TFE_Op("ParseExample")
+  op.setAttr("Nsparse", sparseKeys.count)
+  op.setAttr("Ndense", denseKeys.count)
+  op.setAttr("sparse_types", SparseTypes._typeList)
+  op.setAttr("Tdense", denseDefaults._typeList)
+  op.setAttr("dense_shapes", denseShapes)
+  let _ = op.addInput(serialized)
+  let _ = op.addInput(names)
+  let _ = op.addInputList(sparseKeys)
+  let _ = op.addInputList(denseKeys)
+  let _ = op.addInputList(denseDefaults)
+  return op.execute(Int(sparseKeys.count), Int(SparseTypes._typeList.count), Int(sparseKeys.count), Int(denseDefaults._typeList.count))
+}
+
+/// Transforms a vector of brain.SequenceExample protos (as strings) into typed tensors.
+///
+/// - Parameters:
+///   - serialized: A vector containing binary serialized SequenceExample protos.
+///   - debug_name: A vector containing the names of the serialized protos.
+///     May contain, for example, table key (descriptive) name for the
+///     corresponding serialized proto.  This is purely useful for debugging
+///     purposes, and the presence of values here has no effect on the output.
+///     May also be an empty vector if no name is available.
+///   - context_dense_defaults: A list of Ncontext_dense Tensors (some may be empty).
+///     context_dense_defaults[j] provides default values
+///     when the SequenceExample's context map lacks context_dense_key[j].
+///     If an empty Tensor is provided for context_dense_defaults[j],
+///     then the Feature context_dense_keys[j] is required.
+///     The input type is inferred from context_dense_defaults[j], even when it's
+///     empty.  If context_dense_defaults[j] is not empty, its shape must match
+///     context_dense_shapes[j].
+///
+/// - Attrs:
+///   - feature_list_dense_missing_assumed_empty: A vector listing the
+///     FeatureList keys which may be missing from the SequenceExamples.  If the
+///     associated FeatureList is missing, it is treated as empty.  By default,
+///     any FeatureList not listed in this vector must exist in the SequenceExamples.
+///   - context_sparse_keys: A list of Ncontext_sparse string Tensors (scalars).
+///     The keys expected in the Examples' features associated with context_sparse
+///     values.
+///   - context_dense_keys: A list of Ncontext_dense string Tensors (scalars).
+///     The keys expected in the SequenceExamples' context features associated with
+///     dense values.
+///   - feature_list_sparse_keys: A list of Nfeature_list_sparse string Tensors
+///     (scalars).  The keys expected in the FeatureLists associated with sparse
+///     values.
+///   - feature_list_dense_keys: A list of Nfeature_list_dense string Tensors (scalars).
+///     The keys expected in the SequenceExamples' feature_lists associated
+///     with lists of dense values.
+///   - context_sparse_types: A list of Ncontext_sparse types; the data types of data in
+///     each context Feature given in context_sparse_keys.
+///     Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
+///     DT_INT64 (Int64List), and DT_STRING (BytesList).
+///   - context_dense_shapes: A list of Ncontext_dense shapes; the shapes of data in
+///     each context Feature given in context_dense_keys.
+///     The number of elements in the Feature corresponding to context_dense_key[j]
+///     must always equal context_dense_shapes[j].NumEntries().
+///     The shape of context_dense_values[j] will match context_dense_shapes[j].
+///   - feature_list_sparse_types: A list of Nfeature_list_sparse types; the data types
+///     of data in each FeatureList given in feature_list_sparse_keys.
+///     Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
+///     DT_INT64 (Int64List), and DT_STRING (BytesList).
+///   - feature_list_dense_shapes: A list of Nfeature_list_dense shapes; the shapes of
+///     data in each FeatureList given in feature_list_dense_keys.
+///     The shape of each Feature in the FeatureList corresponding to
+///     feature_list_dense_key[j] must always equal
+///     feature_list_dense_shapes[j].NumEntries().
+@inlinable @inline(__always)
+public static func parseSequenceExample<
+    ContextSparseTypes: TensorGroup,
+    TcontextDense: TensorArrayProtocol,
+    FeatureListDenseTypes: TensorGroup,
+    FeatureListSparseTypes: TensorGroup
+>(
+  serialized: StringTensor,
+  debugName: StringTensor,
+  contextDenseDefaults: TcontextDense,
+  featureListDenseMissingAssumedEmpty: [String],
+  contextSparseKeys: [String],
+  contextDenseKeys: [String],
+  featureListSparseKeys: [String],
+  featureListDenseKeys: [String],
+  ncontextSparse: Int64 = 0,
+  ncontextDense: Int64 = 0,
+  nfeatureListSparse: Int64 = 0,
+  nfeatureListDense: Int64 = 0,
+  contextDenseShapes: [TensorShape?],
+  featureListDenseShapes: [TensorShape?]
+) -> (contextSparseIndices: [Tensor<Int64>], contextSparseValues: ContextSparseTypes, contextSparseShapes: [Tensor<Int64>], contextDenseValues: TcontextDense, featureListSparseIndices: [Tensor<Int64>], featureListSparseValues: FeatureListSparseTypes, featureListSparseShapes: [Tensor<Int64>], featureListDenseValues: FeatureListDenseTypes, featureListDenseLengths: [Tensor<Int64>]) {
+  let op = TFE_Op("ParseSequenceExample")
+  op.setAttr("feature_list_dense_missing_assumed_empty", featureListDenseMissingAssumedEmpty)
+  op.setAttr("context_sparse_keys", contextSparseKeys)
+  op.setAttr("context_dense_keys", contextDenseKeys)
+  op.setAttr("feature_list_sparse_keys", featureListSparseKeys)
+  op.setAttr("feature_list_dense_keys", featureListDenseKeys)
+  op.setAttr("Ncontext_sparse", ncontextSparse)
+  op.setAttr("Ncontext_dense", ncontextDense)
+  op.setAttr("Nfeature_list_sparse", nfeatureListSparse)
+  op.setAttr("Nfeature_list_dense", nfeatureListDense)
+  op.setAttr("context_sparse_types", ContextSparseTypes._typeList)
+  op.setAttr("Tcontext_dense", contextDenseDefaults._typeList)
+  op.setAttr("feature_list_dense_types", FeatureListDenseTypes._typeList)
+  op.setAttr("context_dense_shapes", contextDenseShapes)
+  op.setAttr("feature_list_sparse_types", FeatureListSparseTypes._typeList)
+  op.setAttr("feature_list_dense_shapes", featureListDenseShapes)
+  let _ = op.addInput(serialized)
+  let _ = op.addInput(debugName)
+  let _ = op.addInputList(contextDenseDefaults)
+  return op.execute(Int(ncontextSparse), Int(ContextSparseTypes._typeList.count), Int(ncontextSparse), Int(contextDenseDefaults._typeList.count), Int(nfeatureListSparse), Int(FeatureListSparseTypes._typeList.count), Int(nfeatureListSparse), Int(FeatureListDenseTypes._typeList.count), Int(nfeatureListDense))
+}
+
+/// Transforms a tf.Example proto (as a string) into typed tensors.
+///
+/// - Parameters:
+///   - serialized: A vector containing a batch of binary serialized Example protos.
+///   - dense_defaults: A list of Tensors (some may be empty), whose length matches
+///     the length of `dense_keys`. dense_defaults[j] provides default values
+///     when the example's feature_map lacks dense_key[j].  If an empty Tensor is
+///     provided for dense_defaults[j], then the Feature dense_keys[j] is required.
+///     The input type is inferred from dense_defaults[j], even when it's empty.
+///     If dense_defaults[j] is not empty, and dense_shapes[j] is fully defined,
+///     then the shape of dense_defaults[j] must match that of dense_shapes[j].
+///     If dense_shapes[j] has an undefined major dimension (variable strides dense
+///     feature), dense_defaults[j] must contain a single element:
+///     the padding element.
+///
+/// - Attrs:
+///   - num_sparse: The number of sparse features to be parsed from the example. This
+///     must match the lengths of `sparse_keys` and `sparse_types`.
+///   - sparse_keys: A list of `num_sparse` strings.
+///     The keys expected in the Examples' features associated with sparse values.
+///   - dense_keys: The keys expected in the Examples' features associated with dense
+///     values.
+///   - sparse_types: A list of `num_sparse` types; the data types of data in each
+///     Feature given in sparse_keys.
+///     Currently the ParseSingleExample op supports DT_FLOAT (FloatList),
+///     DT_INT64 (Int64List), and DT_STRING (BytesList).
+///   - Tdense: The data types of data in each Feature given in dense_keys.
+///     The length of this list must match the length of `dense_keys`.
+///     Currently the ParseSingleExample op supports DT_FLOAT (FloatList),
+///     DT_INT64 (Int64List), and DT_STRING (BytesList).
+///   - dense_shapes: The shapes of data in each Feature given in dense_keys.
+///     The length of this list must match the length of `dense_keys`.  The
+///     number of elements in the Feature corresponding to dense_key[j] must
+///     always equal dense_shapes[j].NumEntries().  If dense_shapes[j] ==
+///     (D0, D1, ..., DN) then the shape of output Tensor dense_values[j]
+///     will be (D0, D1, ..., DN): In the case dense_shapes[j] = (-1, D1,
+///     ..., DN), the shape of the output Tensor dense_values[j] will be (M,
+///     D1, .., DN), where M is the number of blocks of elements of length
+///     D1 * .... * DN, in the input.
+@inlinable @inline(__always)
+public static func parseSingleExample<
+    SparseTypes: TensorGroup,
+    Tdense: TensorArrayProtocol
+>(
+  serialized: StringTensor,
+  denseDefaults: Tdense,
+  numSparse: Int64,
+  sparseKeys: [String],
+  denseKeys: [String],
+  denseShapes: [TensorShape?]
+) -> (sparseIndices: [Tensor<Int64>], sparseValues: SparseTypes, sparseShapes: [Tensor<Int64>], denseValues: Tdense) {
+  let op = TFE_Op("ParseSingleExample")
+  op.setAttr("num_sparse", numSparse)
+  op.setAttr("sparse_keys", sparseKeys)
+  op.setAttr("dense_keys", denseKeys)
+  op.setAttr("sparse_types", SparseTypes._typeList)
+  op.setAttr("Tdense", denseDefaults._typeList)
+  op.setAttr("dense_shapes", denseShapes)
+  let _ = op.addInput(serialized)
+  let _ = op.addInputList(denseDefaults)
+  return op.execute(Int(numSparse), Int(SparseTypes._typeList.count), Int(numSparse), Int(denseDefaults._typeList.count))
+}
+
+/// Transforms a scalar brain.SequenceExample proto (as strings) into typed tensors.
+///
+/// - Parameters:
+///   - serialized: A scalar containing a binary serialized SequenceExample proto.
+///   - feature_list_dense_missing_assumed_empty: A vector listing the
+///     FeatureList keys which may be missing from the SequenceExample.  If the
+///     associated FeatureList is missing, it is treated as empty.  By default,
+///     any FeatureList not listed in this vector must exist in the SequenceExample.
+///   - context_sparse_keys: A list of Ncontext_sparse string Tensors (scalars).
+///     The keys expected in the Examples' features associated with context_sparse
+///     values.
+///   - context_dense_keys: A list of Ncontext_dense string Tensors (scalars).
+///     The keys expected in the SequenceExamples' context features associated with
+///     dense values.
+///   - feature_list_sparse_keys: A list of Nfeature_list_sparse string Tensors
+///     (scalars).  The keys expected in the FeatureLists associated with sparse
+///     values.
+///   - feature_list_dense_keys: A list of Nfeature_list_dense string Tensors (scalars).
+///     The keys expected in the SequenceExamples' feature_lists associated
+///     with lists of dense values.
+///   - context_dense_defaults: A list of Ncontext_dense Tensors (some may be empty).
+///     context_dense_defaults[j] provides default values
+///     when the SequenceExample's context map lacks context_dense_key[j].
+///     If an empty Tensor is provided for context_dense_defaults[j],
+///     then the Feature context_dense_keys[j] is required.
+///     The input type is inferred from context_dense_defaults[j], even when it's
+///     empty.  If context_dense_defaults[j] is not empty, its shape must match
+///     context_dense_shapes[j].
+///   - debug_name: A scalar containing the name of the serialized proto.
+///     May contain, for example, table key (descriptive) name for the
+///     corresponding serialized proto.  This is purely useful for debugging
+///     purposes, and the presence of values here has no effect on the output.
+///     May also be an empty scalar if no name is available.
+///
+/// - Attrs:
+///   - context_sparse_types: A list of Ncontext_sparse types; the data types of data in
+///     each context Feature given in context_sparse_keys.
+///     Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
+///     DT_INT64 (Int64List), and DT_STRING (BytesList).
+///   - context_dense_shapes: A list of Ncontext_dense shapes; the shapes of data in
+///     each context Feature given in context_dense_keys.
+///     The number of elements in the Feature corresponding to context_dense_key[j]
+///     must always equal context_dense_shapes[j].NumEntries().
+///     The shape of context_dense_values[j] will match context_dense_shapes[j].
+///   - feature_list_sparse_types: A list of Nfeature_list_sparse types; the data types
+///     of data in each FeatureList given in feature_list_sparse_keys.
+///     Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
+///     DT_INT64 (Int64List), and DT_STRING (BytesList).
+///   - feature_list_dense_shapes: A list of Nfeature_list_dense shapes; the shapes of
+///     data in each FeatureList given in feature_list_dense_keys.
+///     The shape of each Feature in the FeatureList corresponding to
+///     feature_list_dense_key[j] must always equal
+///     feature_list_dense_shapes[j].NumEntries().
+@inlinable @inline(__always)
+public static func parseSingleSequenceExample<
+    ContextSparseTypes: TensorGroup,
+    TcontextDense: TensorArrayProtocol,
+    FeatureListDenseTypes: TensorGroup,
+    FeatureListSparseTypes: TensorGroup
+>(
+  serialized: StringTensor,
+  featureListDenseMissingAssumedEmpty: StringTensor,
+  contextSparseKeys: [StringTensor],
+  contextDenseKeys: [StringTensor],
+  featureListSparseKeys: [StringTensor],
+  featureListDenseKeys: [StringTensor],
+  contextDenseDefaults: TcontextDense,
+  debugName: StringTensor,
+  contextDenseShapes: [TensorShape?],
+  featureListDenseShapes: [TensorShape?]
+) -> (contextSparseIndices: [Tensor<Int64>], contextSparseValues: ContextSparseTypes, contextSparseShapes: [Tensor<Int64>], contextDenseValues: TcontextDense, featureListSparseIndices: [Tensor<Int64>], featureListSparseValues: FeatureListSparseTypes, featureListSparseShapes: [Tensor<Int64>], featureListDenseValues: FeatureListDenseTypes) {
+  let op = TFE_Op("ParseSingleSequenceExample")
+  op.setAttr("Ncontext_sparse", contextSparseKeys.count)
+  op.setAttr("Ncontext_dense", contextDenseKeys.count)
+  op.setAttr("Nfeature_list_sparse", featureListSparseKeys.count)
+  op.setAttr("Nfeature_list_dense", featureListDenseKeys.count)
+  op.setAttr("context_sparse_types", ContextSparseTypes._typeList)
+  op.setAttr("Tcontext_dense", contextDenseDefaults._typeList)
+  op.setAttr("feature_list_dense_types", FeatureListDenseTypes._typeList)
+  op.setAttr("context_dense_shapes", contextDenseShapes)
+  op.setAttr("feature_list_sparse_types", FeatureListSparseTypes._typeList)
+  op.setAttr("feature_list_dense_shapes", featureListDenseShapes)
+  let _ = op.addInput(serialized)
+  let _ = op.addInput(featureListDenseMissingAssumedEmpty)
+  let _ = op.addInputList(contextSparseKeys)
+  let _ = op.addInputList(contextDenseKeys)
+  let _ = op.addInputList(featureListSparseKeys)
+  let _ = op.addInputList(featureListDenseKeys)
+  let _ = op.addInputList(contextDenseDefaults)
+  let _ = op.addInput(debugName)
+  return op.execute(Int(contextSparseKeys.count), Int(ContextSparseTypes._typeList.count), Int(contextSparseKeys.count), Int(contextDenseDefaults._typeList.count), Int(featureListSparseKeys.count), Int(FeatureListSparseTypes._typeList.count), Int(featureListSparseKeys.count), Int(FeatureListDenseTypes._typeList.count))
+}
+
+/// Transforms a serialized tensorflow.TensorProto proto into a Tensor.
+///
+/// - Parameter serialized: A scalar string containing a serialized TensorProto proto.
+///
+/// - Attr out_type: The type of the serialized tensor.  The provided type must match the
+///   type of the serialized tensor and no implicit conversion will take place.
+///
+/// - Output output: A Tensor of type `out_type`.
+@inlinable @inline(__always)
+public static func parseTensor<OutType: TensorFlowScalar>(
+  serialized: StringTensor
+) -> Tensor<OutType> {
+  let op = TFE_Op("ParseTensor")
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(serialized)
+  return op.execute(Int(1))
+}
+
+/// returns `f(inputs)`, where `f`'s body is placed and partitioned.
+///
+/// - Parameter args: A list of input tensors.
+///
+/// - Attrs:
+///   - Tin: A list of input types.
+///   - Tout: A list of output types.
+///   - f:       A function that takes 'args', a list of tensors, and returns 'output',
+///           another list of tensors. Input and output types are specified by 'Tin'
+///           and 'Tout'. The function body of f will be placed and partitioned across
+///           devices, setting this op apart from the regular Call op.
+///
+/// - Output output: A list of return values.
+@inlinable @inline(__always)
+public static func partitionedCall<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    FIn: TensorGroup,
+    FOut: TensorGroup
+>(
+  args: Tin,
+  f: (FIn) -> FOut,
+  config: String,
+  configProto: String,
+  executorType: String
+) -> Tout {
+  let op = TFE_Op("PartitionedCall")
+  op.setAttr("Tin", args._typeList)
+  op.setAttr("Tout", Tout._typeList)
+  op.setAttr("f", f)
+  op.setAttr("config", config)
+  op.setAttr("config_proto", configProto)
+  op.setAttr("executor_type", executorType)
+  let _ = op.addInputList(args)
+  return op.execute(Int(Tout._typeList.count))
+}
+
+/// A placeholder op for a value that will be fed into the computation.
+///
+/// N.B. This operation will fail with an error if it is executed. It is
+/// intended as a way to represent a value that will always be fed, and to
+/// provide attrs that enable the fed value to be checked at runtime.
+///
+/// - Attrs:
+///   - dtype: The type of elements in the tensor.
+///   - shape: (Optional) The shape of the tensor. If the shape has 0 dimensions, the
+///     shape is unconstrained.
+///
+/// - Output output: A placeholder tensor that must be replaced using the feed mechanism.
+@inlinable @inline(__always)
+public static func placeholder<Dtype: TensorFlowScalar>(
+  shape: TensorShape?
+) -> Tensor<Dtype> {
+  let op = TFE_Op("Placeholder")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape", shape)
+  return op.execute(Int(1))
+}
+
+/// A placeholder op for a value that will be fed into the computation.
+///
+/// N.B. This operation will fail with an error if it is executed. It is
+/// intended as a way to represent a value that will always be fed, and to
+/// provide attrs that enable the fed value to be checked at runtime.
+///
+/// - Attrs:
+///   - dtype: The type of elements in the tensor.
+///   - shape: The shape of the tensor. The shape can be any partially-specified
+///     shape.  To be unconstrained, pass in a shape with unknown rank.
+///
+/// - Output output: A placeholder tensor that must be replaced using the feed mechanism.
+@inlinable @inline(__always)
+public static func placeholderV2<Dtype: TensorFlowScalar>(
+  shape: TensorShape?
+) -> Tensor<Dtype> {
+  let op = TFE_Op("PlaceholderV2")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape", shape)
+  return op.execute(Int(1))
+}
+
+/// A placeholder op that passes through `input` when its output is not fed.
+///
+/// - Parameter input: The default value to produce when `output` is not fed.
+///
+/// - Attrs:
+///   - dtype: The type of elements in the tensor.
+///   - shape: The (possibly partial) shape of the tensor.
+///
+/// - Output output: A placeholder tensor that defaults to `input` if it is not fed.
+@inlinable @inline(__always)
+public static func placeholderWithDefault<Dtype: TensorFlowScalar>(
+  _ input: Tensor<Dtype>,
+  shape: TensorShape?
+) -> Tensor<Dtype> {
+  let op = TFE_Op("PlaceholderWithDefault")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape", shape)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Compute the polygamma function \\(\psi^{(n)}(x)\\).
+///
+/// The polygamma function is defined as:
+///
+///
+/// \\(\psi^{(a)}(x) = \frac{d^a}{dx^a} \psi(x)\\)
+///
+/// where \\(\psi(x)\\) is the digamma function.
+/// The polygamma function is defined only for non-negative integer orders \\a\\.
+@inlinable @inline(__always)
+public static func polygamma<T: FloatingPoint & TensorFlowScalar>(
+  _ a: Tensor<T>,
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Polygamma")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func polymorphic<T: TensorFlowScalar>(
+  _ a: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Polymorphic")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func polymorphicDefaultOut<T: TensorFlowScalar>(
+) -> Tensor<T> {
+  let op = TFE_Op("PolymorphicDefaultOut")
+  op.setAttr("T", T.tensorFlowDataType)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func polymorphicOut<T: TensorFlowScalar>(
+) -> Tensor<T> {
+  let op = TFE_Op("PolymorphicOut")
+  op.setAttr("T", T.tensorFlowDataType)
+  return op.execute(Int(1))
+}
+
+/// Computes element-wise population count (a.k.a. popcount, bitsum, bitcount).
+///
+/// For each entry in `x`, calculates the number of `1` (on) bits in the binary
+/// representation of that entry.
+///
+/// **NOTE**: It is more efficient to first `tf.bitcast` your tensors into
+/// `int32` or `int64` and perform the bitcount on the result, than to feed in
+/// 8- or 16-bit inputs and then aggregate the resulting counts.
+@inlinable @inline(__always)
+public static func populationCount<T: BinaryInteger & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<UInt8> {
+  let op = TFE_Op("PopulationCount")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the power of one value to another.
+///
+/// Given a tensor `x` and a tensor `y`, this operation computes \\(x^y\\) for
+/// corresponding elements in `x` and `y`. For example:
+///
+/// ```
+/// # tensor 'x' is [[2, 2]], [3, 3]]
+/// # tensor 'y' is [[8, 16], [2, 3]]
+/// tf.pow(x, y) ==> [[256, 65536], [9, 27]]
+/// ```
+@inlinable @inline(__always)
+public static func pow<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Pow")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that asynchronously prefetches elements from `input_dataset`.
+///
+/// - Parameter buffer_size: The maximum number of elements to buffer in an iterator over
+///   this dataset.
+@inlinable @inline(__always)
+public static func prefetchDataset(
+  inputDataset: VariantHandle,
+  bufferSize: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("PrefetchDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(bufferSize)
+  return op.execute(Int(1))
+}
+
+/// An op which linearizes one Tensor value to an opaque variant tensor.
+///
+/// - Parameter input: A tensor that will be linearized.
+///
+/// - Attrs:
+///   - dtype: The type of elements in the tensor.
+///   - shape: The shape of the tensor.
+///   - layout: A vector holding the requested layout in minor-to-major sequence. If a layout
+///     attribute is passed but its values are all -1 the layout will be computed by
+///     the infeed operation.
+@inlinable @inline(__always)
+public static func prelinearize<Dtype: TensorFlowScalar>(
+  _ input: Tensor<Dtype>,
+  shape: TensorShape?,
+  layout: [Int32]
+) -> VariantHandle {
+  let op = TFE_Op("Prelinearize")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape", shape)
+  op.setAttr("layout", layout)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// An op which linearizes multiple Tensor values to an opaque variant tensor.
+///
+/// - Parameter inputs: A list of tensors that will be provided using the infeed mechanism.
+///
+/// - Attrs:
+///   - dtypes: The element types of each element in `inputs`.
+///   - shapes: The shapes of each tensor in `inputs`.
+///   - layouts: A vector holding the requested layout in minor-to-major sequence for all the
+///     tuple shapes in the order the shapes appear in the "shapes" input. The layout
+///     elements for a sub-shape can be set to -1 in which case the corresponding layout
+///     will be computed by the infeed operation.
+@inlinable @inline(__always)
+public static func prelinearizeTuple<Dtypes: TensorArrayProtocol>(
+  inputs: Dtypes,
+  shapes: [TensorShape?],
+  layouts: [Int32]
+) -> VariantHandle {
+  let op = TFE_Op("PrelinearizeTuple")
+  op.setAttr("dtypes", inputs._typeList)
+  op.setAttr("shapes", shapes)
+  op.setAttr("layouts", layouts)
+  let _ = op.addInputList(inputs)
+  return op.execute(Int(1))
+}
+
+/// 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.
+///
+/// - Parameter input: any tensor.
+///
+/// - Attr message: Will be printed in the error when anyone tries to differentiate
+///   this operation.
+///
+/// - Output output: the same input tensor.
+@inlinable @inline(__always)
+public static func preventGradient<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  message: String
+) -> Tensor<T> {
+  let op = TFE_Op("PreventGradient")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("message", message)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Prints a list of tensors.
+///
+/// Passes `input` through to `output` and prints `data` when evaluating.
+///
+/// - Parameters:
+///   - input: The tensor passed to `output`
+///   - data: A list of tensors to print out when op is evaluated.
+///
+/// - Attrs:
+///   - message: A string, prefix of the error message.
+///   - first_n: Only log `first_n` number of times. -1 disables logging.
+///   - summarize: Only print this many entries of each tensor.
+///
+/// - Output output: = The unmodified `input` tensor
+@inlinable @inline(__always)
+public static func print<
+    T: TensorFlowScalar,
+    U: TensorArrayProtocol
+>(
+  _ input: Tensor<T>,
+  data: U,
+  message: String,
+  firstN: Int64 = -1,
+  summarize: Int64 = 3
+) -> Tensor<T> {
+  let op = TFE_Op("Print")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("U", data._typeList)
+  op.setAttr("message", message)
+  op.setAttr("first_n", firstN)
+  op.setAttr("summarize", summarize)
+  let _ = op.addInput(input)
+  let _ = op.addInputList(data)
+  return op.execute(Int(1))
+}
+
+/// Prints a string scalar.
+///
+/// Prints a string scalar to the desired output_stream.
+///
+/// - Parameter input: The string scalar to print.
+///
+/// - Attr output_stream: A string specifying the output stream or logging level to print to.
+@inlinable @inline(__always)
+public static func printV2(
+  _ input: StringTensor,
+  outputStream: String = "stderr"
+) {
+  let op = TFE_Op("PrintV2")
+  op.setAttr("output_stream", outputStream)
+  let _ = op.addInput(input)
+  op.execute()
+}
+
+/// A queue that produces elements sorted by the first component value.
+///
+/// Note that the PriorityQueue requires the first component of any element
+/// to be a scalar int64, in addition to the other elements declared by
+/// component_types.  Therefore calls to Enqueue and EnqueueMany (resp. Dequeue
+/// and DequeueMany) on a PriorityQueue will all require (resp. output) one extra
+/// entry in their input (resp. output) lists.
+///
+/// - Attrs:
+///   - component_types: The type of each component in a value.
+///   - shapes: The shape of each component in a value. The length of this attr must
+///     be either 0 or the same as the length of component_types. If the length of
+///     this attr is 0, the shapes of queue elements are not constrained, and
+///     only one element may be dequeued at a time.
+///   - capacity: The upper bound on the number of elements in this queue.
+///     Negative numbers mean no limit.
+///   - container: If non-empty, this queue is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this queue will be shared under the given name
+///     across multiple sessions.
+///
+/// - Output handle: The handle to the queue.
+@inlinable @inline(__always)
+public static func priorityQueueV2(
+  componentTypes: [TensorDataType],
+  shapes: [TensorShape?],
+  capacity: Int64 = -1,
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("PriorityQueueV2")
+  op.setAttr("component_types", componentTypes)
+  op.setAttr("shapes", shapes)
+  op.setAttr("capacity", capacity)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Computes the product of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///   - input: The tensor to reduce.
+///   - reduction_indices: The dimensions to reduce. Must be in the range
+///     `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func prod<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  reductionIndices: Tensor<Tidx>,
+  keepDims: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("Prod")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(reductionIndices)
+  return op.execute(Int(1))
+}
+
+/// Invokes a python function to compute func(input)->output.
+///
+/// This operation is considered stateful. For a stateless version, see
+/// PyFuncStateless.
+///
+/// - Parameter input: List of Tensors that will provide input to the Op.
+///
+/// - Attrs:
+///   - token: A token representing a registered python function in this address space.
+///   - Tin: Data types of the inputs to the op.
+///   - Tout: Data types of the outputs from the op.
+///     The length of the list specifies the number of outputs.
+///
+/// - Output output: The outputs from the Op.
+@inlinable @inline(__always)
+public static func pyFunc<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup
+>(
+  _ input: Tin,
+  token: String
+) -> Tout {
+  let op = TFE_Op("PyFunc")
+  op.setAttr("token", token)
+  op.setAttr("Tin", input._typeList)
+  op.setAttr("Tout", Tout._typeList)
+  let _ = op.addInputList(input)
+  return op.execute(Int(Tout._typeList.count))
+}
+
+/// A stateless version of PyFunc.
+@inlinable @inline(__always)
+public static func pyFuncStateless<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup
+>(
+  _ input: Tin,
+  token: String
+) -> Tout {
+  let op = TFE_Op("PyFuncStateless")
+  op.setAttr("token", token)
+  op.setAttr("Tin", input._typeList)
+  op.setAttr("Tout", Tout._typeList)
+  let _ = op.addInputList(input)
+  return op.execute(Int(Tout._typeList.count))
+}
+
+/// Computes the QR decompositions of one or more matrices.
+///
+/// Computes the QR decomposition of each inner matrix in `tensor` such that
+/// `tensor[..., :, :] = q[..., :, :] * r[..., :,:])`
+///
+/// ```python
+/// # a is a tensor.
+/// # q is a tensor of orthonormal matrices.
+/// # r is a tensor of upper triangular matrices.
+/// q, r = qr(a)
+/// q_full, r_full = qr(a, full_matrices=True)
+/// ```
+///
+/// - Parameter input: A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
+///   form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
+///
+/// - Attr full_matrices: If true, compute full-sized `q` and `r`. If false
+///   (the default), compute only the leading `P` columns of `q`.
+///
+/// - Outputs:
+///   - q: Orthonormal basis for range of `a`. If `full_matrices` is `False` then
+///     shape is `[..., M, P]`; if `full_matrices` is `True` then shape is
+///     `[..., M, M]`.
+///   - r: Triangular factor. If `full_matrices` is `False` then shape is
+///     `[..., P, N]`. If `full_matrices` is `True` then shape is `[..., M, N]`.
+@inlinable @inline(__always)
+public static func qr<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  fullMatrices: Bool = false
+) -> (q: Tensor<T>, r: Tensor<T>) {
+  let op = TFE_Op("Qr")
+  op.setAttr("full_matrices", fullMatrices)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Use QuantizeAndDequantizeV2 instead.
+@inlinable @inline(__always)
+public static func quantizeAndDequantize<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  signedInput: Bool = true,
+  numBits: Int64 = 8,
+  rangeGiven: Bool = false,
+  inputMin: Double = 0,
+  inputMax: Double = 0
+) -> Tensor<T> {
+  let op = TFE_Op("QuantizeAndDequantize")
+  op.setAttr("signed_input", signedInput)
+  op.setAttr("num_bits", numBits)
+  op.setAttr("range_given", rangeGiven)
+  op.setAttr("input_min", inputMin)
+  op.setAttr("input_max", inputMax)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Quantizes then dequantizes a tensor.
+///
+/// This op simulates the precision loss from the quantized forward pass by:
+///
+/// 1. Quantizing the tensor to fixed point numbers, which should match the target
+///    quantization method when it is used in inference.
+/// 2. Dequantizing it back to floating point numbers for the following ops, most
+///    likely matmul.
+///
+/// There are different ways to quantize. This version uses only scaling, so 0.0
+/// maps to 0.
+///
+/// From the specified 'num_bits' in the quantized output type, it determines
+/// minimum and maximum representable quantized values.
+///
+/// e.g.
+///
+/// *   [-128, 127] for signed, num_bits = 8, or
+/// *   [0, 255] for unsigned, num_bits = 8.
+///
+/// If range_given == False, the initial input_min, input_max will be determined
+/// automatically as the minimum and maximum values in the input tensor, otherwise
+/// the specified values of input_min, input_max are used.
+///
+/// Note: If the input_min, input_max are specified, they do not need to equal the
+/// actual minimum and maximum values in the tensor. e.g. in some cases it may be
+/// beneficial to specify these values such that the low probability extremes of the
+/// input distribution are clipped.
+///
+/// This op determines the maximum scale_factor that would map the initial
+/// [input_min, input_max] range to a range that lies within the representable
+/// quantized range.
+///
+/// It determines the scale from one of input_min and input_max, then updates the
+/// other one to maximize the respresentable range.
+///
+/// e.g.
+///
+/// *   if the output is signed, num_bits = 8, [input_min, input_max] = [-10.0,
+///     5.0]: it would use a scale_factor of -128 / -10.0 = 12.8 In this case, it
+///     would update input_max to be 127 / 12.8 = 9.921875
+/// *   if the output is signed, num_bits = 8, [input_min, input_max] = [-10.0,
+///     10.0]: it would use a scale_factor of 127 / 10.0 = 12.7 In this case, it
+///     would update input_min to be 128.0 / 12.7 = -10.07874
+/// *   if the output is unsigned, input_min is forced to be 0, and only the
+///     specified input_max is used.
+///
+/// After determining the scale_factor and updating the input range, it applies the
+/// following to each value in the 'input' tensor.
+///
+/// output = round(clamp(value, input_min, input_max) * scale_factor) / scale_factor.
+///
+/// The above round function rounds the value based on the given round_mode.
+///
+///
+/// - Parameters:
+///   - input: Tensor to quantize and then dequantize.
+///   - input_min: If `range_given == True`, this specifies the minimum input value that needs to
+///     be represented, otherwise it is determined from the min value of the `input`
+///     tensor.
+///   - input_max: If `range_given == True`, this specifies the maximum input value that needs to
+///     be represented, otherwise it is determined from the max value of the `input`
+///     tensor.
+///
+/// - Attrs:
+///   - signed_input: Whether the quantization is signed or unsigned. (actually this parameter should
+///     have been called <b>`signed_output`</b>)
+///   - num_bits: The bitwidth of the quantization.
+///   - range_given: Whether the range is given or should be determined from the `input` tensor.
+///   - round_mode: The 'round_mode' attribute controls which rounding tie-breaking algorithm is
+///     used when rounding float values to their quantized equivalents. The following
+///     rounding modes are currently supported:
+///
+///     *   HALF_TO_EVEN: this is the default round_mode.
+///     *   HALF_UP: round towards positive. In this mode 7.5 rounds up to 8 and -7.5
+///         rounds up to -7.
+///
+@inlinable @inline(__always)
+public static func quantizeAndDequantizeV2<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  inputMin: Tensor<T>,
+  inputMax: Tensor<T>,
+  signedInput: Bool = true,
+  numBits: Int64 = 8,
+  rangeGiven: Bool = false,
+  roundMode: RoundMode = .halfToEven
+) -> Tensor<T> {
+  let op = TFE_Op("QuantizeAndDequantizeV2")
+  op.setAttr("signed_input", signedInput)
+  op.setAttr("num_bits", numBits)
+  op.setAttr("range_given", rangeGiven)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("round_mode", roundMode.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputMin)
+  let _ = op.addInput(inputMax)
+  return op.execute(Int(1))
+}
+
+/// Quantizes then dequantizes a tensor.
+///
+/// This is almost identical to QuantizeAndDequantizeV2, except that num_bits is a
+/// tensor, so its value can change during training.
+@inlinable @inline(__always)
+public static func quantizeAndDequantizeV3<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  inputMin: Tensor<T>,
+  inputMax: Tensor<T>,
+  numBits: Tensor<Int32>,
+  signedInput: Bool = true,
+  rangeGiven: Bool = true
+) -> Tensor<T> {
+  let op = TFE_Op("QuantizeAndDequantizeV3")
+  op.setAttr("signed_input", signedInput)
+  op.setAttr("range_given", rangeGiven)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputMin)
+  let _ = op.addInput(inputMax)
+  let _ = op.addInput(numBits)
+  return op.execute(Int(1))
+}
+
+/// Convert the quantized 'input' tensor into a lower-precision 'output', using the
+///
+/// actual distribution of the values to maximize the usage of the lower bit depth
+/// and adjusting the output min and max ranges accordingly.
+///
+/// [input_min, input_max] are scalar floats that specify the range for the float
+/// interpretation of the 'input' data. For example, if input_min is -1.0f and
+/// input_max is 1.0f, and we are dealing with quint16 quantized data, then a 0
+/// value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.
+///
+/// This operator tries to squeeze as much precision as possible into an output with
+/// a lower bit depth by calculating the actual min and max values found in the
+/// data. For example, maybe that quint16 input has no values lower than 16,384 and
+/// none higher than 49,152. That means only half the range is actually needed, all
+/// the float interpretations are between -0.5f and 0.5f, so if we want to compress
+/// the data into a quint8 output, we can use that range rather than the theoretical
+/// -1.0f to 1.0f that is suggested by the input min and max.
+///
+/// In practice, this is most useful for taking output from operations like
+/// QuantizedMatMul that can produce higher bit-depth outputs than their inputs and
+/// may have large potential output ranges, but in practice have a distribution of
+/// input values that only uses a small fraction of the possible range. By feeding
+/// that output into this operator, we can reduce it from 32 bits down to 8 with
+/// minimal loss of accuracy.
+///
+/// - Parameters:
+///   - input_min: The float value that the minimum quantized input value represents.
+///   - input_max: The float value that the maximum quantized input value represents.
+///
+/// - Attrs:
+///   - Tinput: The type of the input.
+///   - out_type: The type of the output. Should be a lower bit depth than Tinput.
+///
+/// - Outputs:
+///   - output_min: The float value that the minimum quantized output value represents.
+///   - output_max: The float value that the maximum quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizeDownAndShrinkRange<
+    Tinput: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  inputMin: Tensor<Float>,
+  inputMax: Tensor<Float>
+) -> (output: Tensor<OutType>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let op = TFE_Op("QuantizeDownAndShrinkRange")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputMin)
+  let _ = op.addInput(inputMax)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Quantize the 'input' tensor of type float to 'output' tensor of type 'T'.
+///
+/// [min_range, max_range] are scalar floats that specify the range for
+/// the 'input' data. The 'mode' attribute controls exactly which calculations are
+/// used to convert the float values to their quantized equivalents.  The
+/// 'round_mode' attribute controls which rounding tie-breaking algorithm is used
+/// when rounding float values to their quantized equivalents.
+///
+/// In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:
+///
+/// ```
+/// out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
+/// if T == qint8: out[i] -= (range(T) + 1) / 2.0
+/// ```
+///
+/// here `range(T) = numeric_limits<T>::max() - numeric_limits<T>::min()`
+///
+/// *MIN_COMBINED Mode Example*
+///
+/// Assume the input is type float and has a possible range of [0.0, 6.0] and the
+/// output type is quint8 ([0, 255]). The min_range and max_range values should be
+/// specified as 0.0 and 6.0. Quantizing from float to quint8 will multiply each
+/// value of the input by 255/6 and cast to quint8.
+///
+/// If the output type was qint8 ([-128, 127]), the operation will additionally
+/// subtract each value by 128 prior to casting, so that the range of values aligns
+/// with the range of qint8.
+///
+/// If the mode is 'MIN_FIRST', then this approach is used:
+///
+/// ```
+/// num_discrete_values = 1 << (# of bits in T)
+/// range_adjust = num_discrete_values / (num_discrete_values - 1)
+/// range = (range_max - range_min) * range_adjust
+/// range_scale = num_discrete_values / range
+/// quantized = round(input * range_scale) - round(range_min * range_scale) +
+///   numeric_limits<T>::min()
+/// quantized = max(quantized, numeric_limits<T>::min())
+/// quantized = min(quantized, numeric_limits<T>::max())
+/// ```
+///
+/// The biggest difference between this and MIN_COMBINED is that the minimum range
+/// is rounded first, before it's subtracted from the rounded value. With
+/// MIN_COMBINED, a small bias is introduced where repeated iterations of quantizing
+/// and dequantizing will introduce a larger and larger error.
+///
+/// *SCALED mode Example*
+///
+/// `SCALED` mode matches the quantization approach used in
+/// `QuantizeAndDequantize{V2|V3}`.
+///
+/// If the mode is `SCALED`, we do not use the full range of the output type,
+/// choosing to elide the lowest possible value for symmetry (e.g., output range is
+/// -127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to
+/// 0.
+///
+/// We first find the range of values in our tensor. The
+/// range we use is always centered on 0, so we find m such that
+///
+/// ```c++
+///   m = max(abs(input_min), abs(input_max))
+/// ```
+///
+/// Our input tensor range is then `[-m, m]`.
+///
+/// Next, we choose our fixed-point quantization buckets, `[min_fixed, max_fixed]`.
+/// If T is signed, this is
+///
+/// ```
+///   num_bits = sizeof(T) * 8
+///   [min_fixed, max_fixed] =
+///       [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]
+/// ```
+///
+/// Otherwise, if T is unsigned, the fixed-point range is
+///
+/// ```
+///   [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]
+/// ```
+///
+/// From this we compute our scaling factor, s:
+///
+/// ```c++
+///   s = (max_fixed - min_fixed) / (2 * m)
+/// ```
+///
+/// Now we can quantize the elements of our tensor:
+///
+/// ```c++
+/// result = round(input * s)
+/// ```
+///
+/// One thing to watch out for is that the operator may choose to adjust the
+/// requested minimum and maximum values slightly during the quantization process,
+/// so you should always use the output ports as the range for further calculations.
+/// For example, if the requested minimum and maximum values are close to equal,
+/// they will be separated by a small epsilon value to prevent ill-formed quantized
+/// buffers from being created. Otherwise, you can end up with buffers where all the
+/// quantized values map to the same float value, which causes problems for
+/// operations that have to perform further calculations on them.
+///
+/// - Parameters:
+///   - min_range: The minimum scalar value possibly produced for the input.
+///   - max_range: The maximum scalar value possibly produced for the input.
+///
+/// - Outputs:
+///   - output: The quantized data produced from the float input.
+///   - output_min: The actual minimum scalar value used for the output.
+///   - output_max: The actual maximum scalar value used for the output.
+@inlinable @inline(__always)
+public static func quantizeV2<T: TensorFlowScalar>(
+  _ input: Tensor<Float>,
+  minRange: Tensor<Float>,
+  maxRange: Tensor<Float>,
+  mode: Mode = .minCombined,
+  roundMode: RoundMode6 = .halfAwayFromZero
+) -> (output: Tensor<T>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let op = TFE_Op("QuantizeV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("mode", mode.cName)
+  op.setAttr("round_mode", roundMode.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(minRange)
+  let _ = op.addInput(maxRange)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Returns x + y element-wise, working on quantized buffers.
+///
+/// - Parameters:
+///   - min_x: The float value that the lowest quantized `x` value represents.
+///   - max_x: The float value that the highest quantized `x` value represents.
+///   - min_y: The float value that the lowest quantized `y` value represents.
+///   - max_y: The float value that the highest quantized `y` value represents.
+///
+/// - Outputs:
+///   - min_z: The float value that the lowest quantized output value represents.
+///   - max_z: The float value that the highest quantized output value represents.
+///
+///     *NOTE*: `QuantizedAdd` supports limited forms of broadcasting. More about
+///     broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func quantizedAdd<
+    T1: TensorFlowScalar,
+    T2: TensorFlowScalar,
+    Toutput: TensorFlowScalar
+>(
+  _ x: Tensor<T1>,
+  _ y: Tensor<T2>,
+  minX: Tensor<Float>,
+  maxX: Tensor<Float>,
+  minY: Tensor<Float>,
+  maxY: Tensor<Float>
+) -> (z: Tensor<Toutput>, minZ: Tensor<Float>, maxZ: Tensor<Float>) {
+  let op = TFE_Op("QuantizedAdd")
+  op.setAttr("T1", T1.tensorFlowDataType)
+  op.setAttr("T2", T2.tensorFlowDataType)
+  op.setAttr("Toutput", Toutput.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  let _ = op.addInput(minX)
+  let _ = op.addInput(maxX)
+  let _ = op.addInput(minY)
+  let _ = op.addInput(maxY)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Produces the average pool of the input tensor for quantized types.
+///
+/// - Parameters:
+///   - input: 4-D with shape `[batch, height, width, channels]`.
+///   - min_input: The float value that the lowest quantized input value represents.
+///   - max_input: The float value that the highest quantized input value represents.
+///
+/// - Attrs:
+///   - ksize: The size of the window for each dimension of the input tensor.
+///     The length must be 4 to match the number of dimensions of the input.
+///   - strides: The stride of the sliding window for each dimension of the input
+///     tensor.  The length must be 4 to match the number of dimensions of the input.
+///   - padding: The type of padding algorithm to use.
+///
+/// - Outputs:
+///   - min_output: The float value that the lowest quantized output value represents.
+///   - max_output: The float value that the highest quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizedAvgPool<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding
+) -> (output: Tensor<T>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedAvgPool")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Quantized Batch normalization.
+///
+/// This op is deprecated and will be removed in the future. Prefer
+/// `tf.nn.batch_normalization`.
+///
+/// - Parameters:
+///   - t: A 4D input Tensor.
+///   - t_min: The value represented by the lowest quantized input.
+///   - t_max: The value represented by the highest quantized input.
+///   - m: A 1D mean Tensor with size matching the last dimension of t.
+///     This is the first output from tf.nn.moments,
+///     or a saved moving average thereof.
+///   - m_min: The value represented by the lowest quantized mean.
+///   - m_max: The value represented by the highest quantized mean.
+///   - v: A 1D variance Tensor with size matching the last dimension of t.
+///     This is the second output from tf.nn.moments,
+///     or a saved moving average thereof.
+///   - v_min: The value represented by the lowest quantized variance.
+///   - v_max: The value represented by the highest quantized variance.
+///   - beta: A 1D beta Tensor with size matching the last dimension of t.
+///     An offset to be added to the normalized tensor.
+///   - beta_min: The value represented by the lowest quantized offset.
+///   - beta_max: The value represented by the highest quantized offset.
+///   - gamma: A 1D gamma Tensor with size matching the last dimension of t.
+///     If "scale_after_normalization" is true, this tensor will be multiplied
+///     with the normalized tensor.
+///   - gamma_min: The value represented by the lowest quantized gamma.
+///   - gamma_max: The value represented by the highest quantized gamma.
+///
+/// - Attrs:
+///   - variance_epsilon: A small float number to avoid dividing by 0.
+///   - scale_after_normalization: A bool indicating whether the resulted tensor
+///     needs to be multiplied with gamma.
+@inlinable @inline(__always)
+public static func quantizedBatchNormWithGlobalNormalization<
+    Tinput: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  t: Tensor<Tinput>,
+  tMin: Tensor<Float>,
+  tMax: Tensor<Float>,
+  m: Tensor<Tinput>,
+  mMin: Tensor<Float>,
+  mMax: Tensor<Float>,
+  v: Tensor<Tinput>,
+  vMin: Tensor<Float>,
+  vMax: Tensor<Float>,
+  beta: Tensor<Tinput>,
+  betaMin: Tensor<Float>,
+  betaMax: Tensor<Float>,
+  gamma: Tensor<Tinput>,
+  gammaMin: Tensor<Float>,
+  gammaMax: Tensor<Float>,
+  varianceEpsilon: Double,
+  scaleAfterNormalization: Bool
+) -> (result: Tensor<OutType>, resultMin: Tensor<Float>, resultMax: Tensor<Float>) {
+  let op = TFE_Op("QuantizedBatchNormWithGlobalNormalization")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("variance_epsilon", varianceEpsilon)
+  op.setAttr("scale_after_normalization", scaleAfterNormalization)
+  let _ = op.addInput(t)
+  let _ = op.addInput(tMin)
+  let _ = op.addInput(tMax)
+  let _ = op.addInput(m)
+  let _ = op.addInput(mMin)
+  let _ = op.addInput(mMax)
+  let _ = op.addInput(v)
+  let _ = op.addInput(vMin)
+  let _ = op.addInput(vMax)
+  let _ = op.addInput(beta)
+  let _ = op.addInput(betaMin)
+  let _ = op.addInput(betaMax)
+  let _ = op.addInput(gamma)
+  let _ = op.addInput(gammaMin)
+  let _ = op.addInput(gammaMax)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Adds Tensor 'bias' to Tensor 'input' for Quantized types.
+///
+/// Broadcasts the values of bias on dimensions 0..N-2 of 'input'.
+///
+/// - Parameters:
+///   - bias: A 1D bias Tensor with size matching the last dimension of 'input'.
+///   - min_input: The float value that the lowest quantized input value represents.
+///   - max_input: The float value that the highest quantized input value represents.
+///   - min_bias: The float value that the lowest quantized bias value represents.
+///   - max_bias: The float value that the highest quantized bias value represents.
+///
+/// - Outputs:
+///   - min_out: The float value that the lowest quantized output value represents.
+///   - max_out: The float value that the highest quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizedBiasAdd<
+    T1: TensorFlowScalar,
+    T2: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<T1>,
+  bias: Tensor<T2>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minBias: Tensor<Float>,
+  maxBias: Tensor<Float>
+) -> (output: Tensor<OutType>, minOut: Tensor<Float>, maxOut: Tensor<Float>) {
+  let op = TFE_Op("QuantizedBiasAdd")
+  op.setAttr("T1", T1.tensorFlowDataType)
+  op.setAttr("T2", T2.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(bias)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minBias)
+  let _ = op.addInput(maxBias)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Concatenates quantized tensors along one dimension.
+///
+/// - Parameters:
+///   - concat_dim: 0-D.  The dimension along which to concatenate.  Must be in the
+///     range [0, rank(values)).
+///   - values: The `N` Tensors to concatenate. Their ranks and types must match,
+///     and their sizes must match in all dimensions except `concat_dim`.
+///   - input_mins: The minimum scalar values for each of the input tensors.
+///   - input_maxes: The maximum scalar values for each of the input tensors.
+///
+/// - Outputs:
+///   - output: A `Tensor` with the concatenation of values stacked along the
+///     `concat_dim` dimension.  This tensor's shape matches that of `values` except
+///     in `concat_dim` where it has the sum of the sizes.
+///   - output_min: The float value that the minimum quantized output value represents.
+///   - output_max: The float value that the maximum quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizedConcat<T: TensorFlowScalar>(
+  concatDim: Tensor<Int32>,
+  _ values: [Tensor<T>],
+  inputMins: [Tensor<Float>],
+  inputMaxes: [Tensor<Float>]
+) -> (output: Tensor<T>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConcat")
+  op.setAttr("N", values.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(concatDim)
+  let _ = op.addInputList(values)
+  let _ = op.addInputList(inputMins)
+  let _ = op.addInputList(inputMaxes)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes a 2D convolution given quantized 4D input and filter tensors.
+///
+/// The inputs are quantized tensors where the lowest value represents the real
+/// number of the associated minimum, and the highest represents the maximum.
+/// This means that you can only interpret the quantized output in the same way, by
+/// taking the returned minimum and maximum values into account.
+///
+/// - Parameters:
+///   - filter: filter's input_depth dimension must match input's depth dimensions.
+///   - min_input: The float value that the lowest quantized input value represents.
+///   - max_input: The float value that the highest quantized input value represents.
+///   - min_filter: The float value that the lowest quantized filter value represents.
+///   - max_filter: The float value that the highest quantized filter value represents.
+///
+/// - Attrs:
+///   - strides: The stride of the sliding window for each dimension of the input
+///     tensor.
+///   - padding: The type of padding algorithm to use.
+///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///     `input`. If set to k > 1, there will be k-1 skipped cells between each
+///     filter element on that dimension. The dimension order is determined by the
+///     value of `data_format`, see above for details. Dilations in the batch and
+///     depth dimensions must be 1.
+///
+/// - Outputs:
+///   - min_output: The float value that the lowest quantized output value represents.
+///   - max_output: The float value that the highest quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizedConv2D<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConv2D")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DAndRelu<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1],
+  paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConv2DAndRelu")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  op.setAttr("padding_list", paddingList)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DAndReluAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  minFreezedOutput: Tensor<Float>,
+  maxFreezedOutput: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1],
+  paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConv2DAndReluAndRequantize")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  op.setAttr("padding_list", paddingList)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  let _ = op.addInput(minFreezedOutput)
+  let _ = op.addInput(maxFreezedOutput)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  minFreezedOutput: Tensor<Float>,
+  maxFreezedOutput: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1],
+  paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConv2DAndRequantize")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  op.setAttr("padding_list", paddingList)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  let _ = op.addInput(minFreezedOutput)
+  let _ = op.addInput(maxFreezedOutput)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes QuantizedConv2D per channel.
+///
+/// - Parameters:
+///   - input: The original input tensor.
+///   - filter: The original filter tensor.
+///   - min_input: The minimum value of the input tensor
+///   - max_input: The maximum value of the input tensor.
+///   - min_filter: The minimum value of the filter tensor.
+///   - max_filter: The maximum value of the filter tensor.
+///
+/// - Attrs:
+///   - Tinput: The quantized type of input tensor that needs to be converted. 
+///   - Tfilter: The quantized type of filter tensor that needs to be converted. 
+///   - out_type: The quantized type of output tensor that needs to be converted.
+///   - strides: list of stride values.
+///   - dilations: list of dilation values.
+///
+/// - Outputs:
+///   - output: The output tensor.
+///   - min_output: The minimum value of the final output tensor.
+///   - max_output: The maximum value of the final output tensor.
+@inlinable @inline(__always)
+public static func quantizedConv2DPerChannel<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConv2DPerChannel")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBias<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  bias: Tensor<Float>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1],
+  paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConv2DWithBias")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  op.setAttr("padding_list", paddingList)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(bias)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBiasAndRelu<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  bias: Tensor<Float>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1],
+  paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConv2DWithBiasAndRelu")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  op.setAttr("padding_list", paddingList)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(bias)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBiasAndReluAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    Tbias: FloatingPoint & TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  bias: Tensor<Tbias>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  minFreezedOutput: Tensor<Float>,
+  maxFreezedOutput: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1],
+  paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConv2DWithBiasAndReluAndRequantize")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("Tbias", Tbias.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  op.setAttr("padding_list", paddingList)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(bias)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  let _ = op.addInput(minFreezedOutput)
+  let _ = op.addInput(maxFreezedOutput)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBiasAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    Tbias: FloatingPoint & TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  bias: Tensor<Tbias>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  minFreezedOutput: Tensor<Float>,
+  maxFreezedOutput: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1],
+  paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConv2DWithBiasAndRequantize")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("Tbias", Tbias.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  op.setAttr("padding_list", paddingList)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(bias)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  let _ = op.addInput(minFreezedOutput)
+  let _ = op.addInput(maxFreezedOutput)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBiasSignedSumAndReluAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    Tbias: FloatingPoint & TensorFlowScalar,
+    Tsummand: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  bias: Tensor<Tbias>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  minFreezedOutput: Tensor<Float>,
+  maxFreezedOutput: Tensor<Float>,
+  summand: Tensor<Tsummand>,
+  minSummand: Tensor<Float>,
+  maxSummand: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1],
+  paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConv2DWithBiasSignedSumAndReluAndRequantize")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("Tbias", Tbias.tensorFlowDataType)
+  op.setAttr("Tsummand", Tsummand.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  op.setAttr("padding_list", paddingList)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(bias)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  let _ = op.addInput(minFreezedOutput)
+  let _ = op.addInput(maxFreezedOutput)
+  let _ = op.addInput(summand)
+  let _ = op.addInput(minSummand)
+  let _ = op.addInput(maxSummand)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBiasSumAndRelu<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  bias: Tensor<Float>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  summand: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1],
+  paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConv2DWithBiasSumAndRelu")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  op.setAttr("padding_list", paddingList)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(bias)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  let _ = op.addInput(summand)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBiasSumAndReluAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    Tbias: FloatingPoint & TensorFlowScalar,
+    Tsummand: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  bias: Tensor<Tbias>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  minFreezedOutput: Tensor<Float>,
+  maxFreezedOutput: Tensor<Float>,
+  summand: Tensor<Tsummand>,
+  minSummand: Tensor<Float>,
+  maxSummand: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1],
+  paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedConv2DWithBiasSumAndReluAndRequantize")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("Tbias", Tbias.tensorFlowDataType)
+  op.setAttr("Tsummand", Tsummand.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  op.setAttr("padding_list", paddingList)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(bias)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  let _ = op.addInput(minFreezedOutput)
+  let _ = op.addInput(maxFreezedOutput)
+  let _ = op.addInput(summand)
+  let _ = op.addInput(minSummand)
+  let _ = op.addInput(maxSummand)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedDepthwiseConv2D<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedDepthwiseConv2D")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedDepthwiseConv2DWithBias<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  bias: Tensor<Float>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedDepthwiseConv2DWithBias")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(bias)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedDepthwiseConv2DWithBiasAndRelu<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  bias: Tensor<Float>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedDepthwiseConv2DWithBiasAndRelu")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(bias)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedDepthwiseConv2DWithBiasAndReluAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    Tbias: FloatingPoint & TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  filter: Tensor<Tfilter>,
+  bias: Tensor<Tbias>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  minFilter: Tensor<Float>,
+  maxFilter: Tensor<Float>,
+  minFreezedOutput: Tensor<Float>,
+  maxFreezedOutput: Tensor<Float>,
+  strides: [Int32],
+  padding: Padding,
+  dilations: [Int32] = [1, 1, 1, 1]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
+  op.setAttr("Tbias", Tbias.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  op.setAttr("dilations", dilations)
+  let _ = op.addInput(input)
+  let _ = op.addInput(filter)
+  let _ = op.addInput(bias)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  let _ = op.addInput(minFilter)
+  let _ = op.addInput(maxFilter)
+  let _ = op.addInput(minFreezedOutput)
+  let _ = op.addInput(maxFreezedOutput)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Quantized Instance normalization.
+///
+/// - Parameters:
+///   - x: A 4D input Tensor.
+///   - x_min: The value represented by the lowest quantized input.
+///   - x_max: The value represented by the highest quantized input.
+///
+/// - Attrs:
+///   - output_range_given: If True, `given_y_min` and `given_y_min`
+///     and `given_y_max` are used as the output range. Otherwise,
+///     the implementation computes the output range.
+///   - given_y_min: Output in `y_min` if `output_range_given` is True.
+///   - given_y_max: Output in `y_max` if `output_range_given` is True.
+///   - variance_epsilon: A small float number to avoid dividing by 0.
+///   - min_separation: Minimum value of `y_max - y_min`
+///
+/// - Outputs:
+///   - y: A 4D Tensor.
+///   - y_min: The value represented by the lowest quantized output.
+///   - y_max: The value represented by the highest quantized output.
+@inlinable @inline(__always)
+public static func quantizedInstanceNorm<T: TensorFlowScalar>(
+  _ x: Tensor<T>,
+  xMin: Tensor<Float>,
+  xMax: Tensor<Float>,
+  outputRangeGiven: Bool = false,
+  givenYMin: Double = 0,
+  givenYMax: Double = 0,
+  varianceEpsilon: Double = 1e-05,
+  minSeparation: Double = 0.001
+) -> (y: Tensor<T>, yMin: Tensor<Float>, yMax: Tensor<Float>) {
+  let op = TFE_Op("QuantizedInstanceNorm")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("output_range_given", outputRangeGiven)
+  op.setAttr("given_y_min", givenYMin)
+  op.setAttr("given_y_max", givenYMax)
+  op.setAttr("variance_epsilon", varianceEpsilon)
+  op.setAttr("min_separation", minSeparation)
+  let _ = op.addInput(x)
+  let _ = op.addInput(xMin)
+  let _ = op.addInput(xMax)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Perform a quantized matrix multiplication of  `a` by the matrix `b`.
+///
+/// The inputs must be two-dimensional matrices and the inner dimension of
+/// `a` (after being transposed if `transpose_a` is non-zero) must match the
+/// outer dimension of `b` (after being transposed if `transposed_b` is
+/// non-zero).
+///
+/// - Parameters:
+///   - a: Must be a two-dimensional tensor.
+///   - b: Must be a two-dimensional tensor.
+///   - min_a: The float value that the lowest quantized `a` value represents.
+///   - max_a: The float value that the highest quantized `a` value represents.
+///   - min_b: The float value that the lowest quantized `b` value represents.
+///   - max_b: The float value that the highest quantized `b` value represents.
+///
+/// - Attrs:
+///   - transpose_a: If true, `a` is transposed before multiplication.
+///   - transpose_b: If true, `b` is transposed before multiplication.
+///   - Tactivation: The type of output produced by activation function
+///     following this operation.
+///
+/// - Outputs:
+///   - min_out: The float value that the lowest quantized output value represents.
+///   - max_out: The float value that the highest quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizedMatMul<
+    T1: TensorFlowScalar,
+    T2: TensorFlowScalar,
+    Toutput: TensorFlowScalar
+>(
+  _ a: Tensor<T1>,
+  _ b: Tensor<T2>,
+  minA: Tensor<Float>,
+  maxA: Tensor<Float>,
+  minB: Tensor<Float>,
+  maxB: Tensor<Float>,
+  transposeA: Bool = false,
+  transposeB: Bool = false,
+  tactivation: TensorDataType
+) -> (out: Tensor<Toutput>, minOut: Tensor<Float>, maxOut: Tensor<Float>) {
+  let op = TFE_Op("QuantizedMatMul")
+  op.setAttr("T1", T1.tensorFlowDataType)
+  op.setAttr("T2", T2.tensorFlowDataType)
+  op.setAttr("Toutput", Toutput.tensorFlowDataType)
+  op.setAttr("transpose_a", transposeA)
+  op.setAttr("transpose_b", transposeB)
+  op.setAttr("Tactivation", tactivation)
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  let _ = op.addInput(minA)
+  let _ = op.addInput(maxA)
+  let _ = op.addInput(minB)
+  let _ = op.addInput(maxB)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Produces the max pool of the input tensor for quantized types.
+///
+/// - Parameters:
+///   - input: The 4D (batch x rows x cols x depth) Tensor to MaxReduce over.
+///   - min_input: The float value that the lowest quantized input value represents.
+///   - max_input: The float value that the highest quantized input value represents.
+///
+/// - Attrs:
+///   - ksize: The size of the window for each dimension of the input tensor.
+///     The length must be 4 to match the number of dimensions of the input.
+///   - strides: The stride of the sliding window for each dimension of the input
+///     tensor. The length must be 4 to match the number of dimensions of the input.
+///   - padding: The type of padding algorithm to use.
+///
+/// - Outputs:
+///   - min_output: The float value that the lowest quantized output value represents.
+///   - max_output: The float value that the highest quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizedMaxPool<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  minInput: Tensor<Float>,
+  maxInput: Tensor<Float>,
+  ksize: [Int32],
+  strides: [Int32],
+  padding: Padding
+) -> (output: Tensor<T>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let op = TFE_Op("QuantizedMaxPool")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("ksize", ksize)
+  op.setAttr("strides", strides)
+  op.setAttr("padding", padding.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(minInput)
+  let _ = op.addInput(maxInput)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Returns x * y element-wise, working on quantized buffers.
+///
+/// - Parameters:
+///   - min_x: The float value that the lowest quantized `x` value represents.
+///   - max_x: The float value that the highest quantized `x` value represents.
+///   - min_y: The float value that the lowest quantized `y` value represents.
+///   - max_y: The float value that the highest quantized `y` value represents.
+///
+/// - Outputs:
+///   - min_z: The float value that the lowest quantized output value represents.
+///   - max_z: The float value that the highest quantized output value represents.
+///
+///     *NOTE*: `QuantizedMul` supports limited forms of broadcasting. More about
+///     broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func quantizedMul<
+    T1: TensorFlowScalar,
+    T2: TensorFlowScalar,
+    Toutput: TensorFlowScalar
+>(
+  _ x: Tensor<T1>,
+  _ y: Tensor<T2>,
+  minX: Tensor<Float>,
+  maxX: Tensor<Float>,
+  minY: Tensor<Float>,
+  maxY: Tensor<Float>
+) -> (z: Tensor<Toutput>, minZ: Tensor<Float>, maxZ: Tensor<Float>) {
+  let op = TFE_Op("QuantizedMul")
+  op.setAttr("T1", T1.tensorFlowDataType)
+  op.setAttr("T2", T2.tensorFlowDataType)
+  op.setAttr("Toutput", Toutput.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  let _ = op.addInput(minX)
+  let _ = op.addInput(maxX)
+  let _ = op.addInput(minY)
+  let _ = op.addInput(maxY)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes Quantized Rectified Linear: `max(features, 0)`
+///
+/// - Parameters:
+///   - min_features: The float value that the lowest quantized value represents.
+///   - max_features: The float value that the highest quantized value represents.
+///
+/// - Outputs:
+///   - activations: Has the same output shape as "features".
+///   - min_activations: The float value that the lowest quantized value represents.
+///   - max_activations: The float value that the highest quantized value represents.
+@inlinable @inline(__always)
+public static func quantizedRelu<
+    Tinput: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  features: Tensor<Tinput>,
+  minFeatures: Tensor<Float>,
+  maxFeatures: Tensor<Float>
+) -> (activations: Tensor<OutType>, minActivations: Tensor<Float>, maxActivations: Tensor<Float>) {
+  let op = TFE_Op("QuantizedRelu")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(features)
+  let _ = op.addInput(minFeatures)
+  let _ = op.addInput(maxFeatures)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes Quantized Rectified Linear 6: `min(max(features, 0), 6)`
+///
+/// - Parameters:
+///   - min_features: The float value that the lowest quantized value represents.
+///   - max_features: The float value that the highest quantized value represents.
+///
+/// - Outputs:
+///   - activations: Has the same output shape as "features".
+///   - min_activations: The float value that the lowest quantized value represents.
+///   - max_activations: The float value that the highest quantized value represents.
+@inlinable @inline(__always)
+public static func quantizedRelu6<
+    Tinput: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  features: Tensor<Tinput>,
+  minFeatures: Tensor<Float>,
+  maxFeatures: Tensor<Float>
+) -> (activations: Tensor<OutType>, minActivations: Tensor<Float>, maxActivations: Tensor<Float>) {
+  let op = TFE_Op("QuantizedRelu6")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(features)
+  let _ = op.addInput(minFeatures)
+  let _ = op.addInput(maxFeatures)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes Quantized Rectified Linear X: `min(max(features, 0), max_value)`
+///
+/// - Parameters:
+///   - min_features: The float value that the lowest quantized value represents.
+///   - max_features: The float value that the highest quantized value represents.
+///
+/// - Outputs:
+///   - activations: Has the same output shape as "features".
+///   - min_activations: The float value that the lowest quantized value represents.
+///   - max_activations: The float value that the highest quantized value represents.
+@inlinable @inline(__always)
+public static func quantizedReluX<
+    Tinput: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  features: Tensor<Tinput>,
+  maxValue: Tensor<Float>,
+  minFeatures: Tensor<Float>,
+  maxFeatures: Tensor<Float>
+) -> (activations: Tensor<OutType>, minActivations: Tensor<Float>, maxActivations: Tensor<Float>) {
+  let op = TFE_Op("QuantizedReluX")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(features)
+  let _ = op.addInput(maxValue)
+  let _ = op.addInput(minFeatures)
+  let _ = op.addInput(maxFeatures)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Reshapes a quantized tensor as per the Reshape op.
+///
+/// ```
+///
+/// - Parameters:
+///   - shape: Defines the shape of the output tensor.
+///   - input_min: The minimum value of the input.
+///   - input_max: The maximum value of the input.
+///
+/// - Outputs:
+///   - output_min: This value is copied from input_min.
+///   - output_max: This value is copied from input_max.
+@inlinable @inline(__always)
+public static func quantizedReshape<
+    T: TensorFlowScalar,
+    Tshape: BinaryInteger & TensorFlowScalar
+>(
+  _ tensor: Tensor<T>,
+  shape: Tensor<Tshape>,
+  inputMin: Tensor<Float>,
+  inputMax: Tensor<Float>
+) -> (output: Tensor<T>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let op = TFE_Op("QuantizedReshape")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tshape", Tshape.tensorFlowDataType)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(inputMin)
+  let _ = op.addInput(inputMax)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Resize quantized `images` to `size` using quantized bilinear interpolation.
+///
+/// Input images and output images must be quantized types.
+///
+/// - Parameters:
+///   - images: 4-D with shape `[batch, height, width, channels]`.
+///   - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+///     new size for the images.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
+///   aligned, preserving the values at the corner pixels. Defaults to false.
+///
+/// - Output resized_images: 4-D with shape
+///   `[batch, new_height, new_width, channels]`.
+@inlinable @inline(__always)
+public static func quantizedResizeBilinear<T: FloatingPoint & TensorFlowScalar>(
+  images: Tensor<T>,
+  size: Tensor<Int32>,
+  min: Tensor<Float>,
+  max: Tensor<Float>,
+  alignCorners: Bool = false,
+  halfPixelCenters: Bool = false
+) -> (resizedImages: Tensor<T>, outMin: Tensor<Float>, outMax: Tensor<Float>) {
+  let op = TFE_Op("QuantizedResizeBilinear")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("align_corners", alignCorners)
+  op.setAttr("half_pixel_centers", halfPixelCenters)
+  let _ = op.addInput(images)
+  let _ = op.addInput(size)
+  let _ = op.addInput(min)
+  let _ = op.addInput(max)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Closes the given queue.
+///
+/// This operation signals that no more elements will be enqueued in the
+/// given queue. Subsequent Enqueue(Many) operations will fail.
+/// Subsequent Dequeue(Many) operations will continue to succeed if
+/// sufficient elements remain in the queue. Subsequent Dequeue(Many)
+/// operations that would block will fail immediately.
+///
+/// - Parameter handle: The handle to a queue.
+///
+/// - Attr cancel_pending_enqueues: If true, all pending enqueue requests that are
+///   blocked on the given queue will be canceled.
+@inlinable @inline(__always)
+public static func queueCloseV2(
+  handle: ResourceHandle,
+  cancelPendingEnqueues: Bool = false
+) {
+  let op = TFE_Op("QueueCloseV2")
+  op.setAttr("cancel_pending_enqueues", cancelPendingEnqueues)
+  let _ = op.addInput(handle)
+  op.execute()
+}
+
+/// Dequeues `n` tuples of one or more tensors from the given queue.
+///
+/// If the queue is closed and there are fewer than `n` elements, then an
+/// OutOfRange error is returned.
+///
+/// This operation concatenates queue-element component tensors along the
+/// 0th dimension to make a single component tensor.  All of the components
+/// in the dequeued tuple will have size `n` in the 0th dimension.
+///
+/// This operation has `k` outputs, where `k` is the number of components in
+/// the tuples stored in the given queue, and output `i` is the ith
+/// component of the dequeued tuple.
+///
+/// N.B. If the queue is empty, this operation will block until `n` elements
+/// have been dequeued (or 'timeout_ms' elapses, if specified).
+///
+/// - Parameters:
+///   - handle: The handle to a queue.
+///   - n: The number of tuples to dequeue.
+///
+/// - Attrs:
+///   - component_types: The type of each component in a tuple.
+///   - timeout_ms: If the queue has fewer than n elements, this operation
+///     will block for up to timeout_ms milliseconds.
+///     Note: This option is not supported yet.
+///
+/// - Output components: One or more tensors that were dequeued as a tuple.
+@inlinable @inline(__always)
+public static func queueDequeueManyV2<ComponentTypes: TensorGroup>(
+  handle: ResourceHandle,
+  n: Tensor<Int32>,
+  timeoutMs: Int64 = -1
+) -> ComponentTypes {
+  let op = TFE_Op("QueueDequeueManyV2")
+  op.setAttr("component_types", ComponentTypes._typeList)
+  op.setAttr("timeout_ms", timeoutMs)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(n)
+  return op.execute(Int(ComponentTypes._typeList.count))
+}
+
+/// Dequeues `n` tuples of one or more tensors from the given queue.
+///
+/// This operation is not supported by all queues.  If a queue does not support
+/// DequeueUpTo, then an Unimplemented error is returned.
+///
+/// If the queue is closed and there are more than 0 but less than `n`
+/// elements remaining, then instead of returning an OutOfRange error like
+/// QueueDequeueMany, less than `n` elements are returned immediately.  If
+/// the queue is closed and there are 0 elements left in the queue, then
+/// an OutOfRange error is returned just like in QueueDequeueMany.
+/// Otherwise the behavior is identical to QueueDequeueMany:
+///
+/// This operation concatenates queue-element component tensors along the
+/// 0th dimension to make a single component tensor.  All of the components
+/// in the dequeued tuple will have size n in the 0th dimension.
+///
+/// This operation has `k` outputs, where `k` is the number of components in
+/// the tuples stored in the given queue, and output `i` is the ith
+/// component of the dequeued tuple.
+///
+/// - Parameters:
+///   - handle: The handle to a queue.
+///   - n: The number of tuples to dequeue.
+///
+/// - Attrs:
+///   - component_types: The type of each component in a tuple.
+///   - timeout_ms: If the queue has fewer than n elements, this operation
+///     will block for up to timeout_ms milliseconds.
+///     Note: This option is not supported yet.
+///
+/// - Output components: One or more tensors that were dequeued as a tuple.
+@inlinable @inline(__always)
+public static func queueDequeueUpToV2<ComponentTypes: TensorGroup>(
+  handle: ResourceHandle,
+  n: Tensor<Int32>,
+  timeoutMs: Int64 = -1
+) -> ComponentTypes {
+  let op = TFE_Op("QueueDequeueUpToV2")
+  op.setAttr("component_types", ComponentTypes._typeList)
+  op.setAttr("timeout_ms", timeoutMs)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(n)
+  return op.execute(Int(ComponentTypes._typeList.count))
+}
+
+/// Dequeues a tuple of one or more tensors from the given queue.
+///
+/// This operation has k outputs, where k is the number of components
+/// in the tuples stored in the given queue, and output i is the ith
+/// component of the dequeued tuple.
+///
+/// N.B. If the queue is empty, this operation will block until an element
+/// has been dequeued (or 'timeout_ms' elapses, if specified).
+///
+/// - Parameter handle: The handle to a queue.
+///
+/// - Attrs:
+///   - component_types: The type of each component in a tuple.
+///   - timeout_ms: If the queue is empty, this operation will block for up to
+///     timeout_ms milliseconds.
+///     Note: This option is not supported yet.
+///
+/// - Output components: One or more tensors that were dequeued as a tuple.
+@inlinable @inline(__always)
+public static func queueDequeueV2<ComponentTypes: TensorGroup>(
+  handle: ResourceHandle,
+  timeoutMs: Int64 = -1
+) -> ComponentTypes {
+  let op = TFE_Op("QueueDequeueV2")
+  op.setAttr("component_types", ComponentTypes._typeList)
+  op.setAttr("timeout_ms", timeoutMs)
+  let _ = op.addInput(handle)
+  return op.execute(Int(ComponentTypes._typeList.count))
+}
+
+/// Enqueues zero or more tuples of one or more tensors in the given queue.
+///
+/// This operation slices each component tensor along the 0th dimension to
+/// make multiple queue elements. All of the tuple components must have the
+/// same size in the 0th dimension.
+///
+/// The components input has k elements, which correspond to the components of
+/// tuples stored in the given queue.
+///
+/// N.B. If the queue is full, this operation will block until the given
+/// elements have been enqueued (or 'timeout_ms' elapses, if specified).
+///
+/// - Parameters:
+///   - handle: The handle to a queue.
+///   - components: One or more tensors from which the enqueued tensors should
+///     be taken.
+///
+/// - Attr timeout_ms: If the queue is too full, this operation will block for up
+///   to timeout_ms milliseconds.
+///   Note: This option is not supported yet.
+@inlinable @inline(__always)
+public static func queueEnqueueManyV2<Tcomponents: TensorArrayProtocol>(
+  handle: ResourceHandle,
+  components: Tcomponents,
+  timeoutMs: Int64 = -1
+) {
+  let op = TFE_Op("QueueEnqueueManyV2")
+  op.setAttr("Tcomponents", components._typeList)
+  op.setAttr("timeout_ms", timeoutMs)
+  let _ = op.addInput(handle)
+  let _ = op.addInputList(components)
+  op.execute()
+}
+
+/// Enqueues a tuple of one or more tensors in the given queue.
+///
+/// The components input has k elements, which correspond to the components of
+/// tuples stored in the given queue.
+///
+/// N.B. If the queue is full, this operation will block until the given
+/// element has been enqueued (or 'timeout_ms' elapses, if specified).
+///
+/// - Parameters:
+///   - handle: The handle to a queue.
+///   - components: One or more tensors from which the enqueued tensors should be taken.
+///
+/// - Attr timeout_ms: If the queue is full, this operation will block for up to
+///   timeout_ms milliseconds.
+///   Note: This option is not supported yet.
+@inlinable @inline(__always)
+public static func queueEnqueueV2<Tcomponents: TensorArrayProtocol>(
+  handle: ResourceHandle,
+  components: Tcomponents,
+  timeoutMs: Int64 = -1
+) {
+  let op = TFE_Op("QueueEnqueueV2")
+  op.setAttr("Tcomponents", components._typeList)
+  op.setAttr("timeout_ms", timeoutMs)
+  let _ = op.addInput(handle)
+  let _ = op.addInputList(components)
+  op.execute()
+}
+
+/// Returns true if queue is closed.
+///
+/// This operation returns true if the queue is closed and false if the queue
+/// is open.
+///
+/// - Parameter handle: The handle to a queue.
+@inlinable @inline(__always)
+public static func queueIsClosedV2(
+  handle: ResourceHandle
+) -> Tensor<Bool> {
+  let op = TFE_Op("QueueIsClosedV2")
+  let _ = op.addInput(handle)
+  return op.execute(Int(1))
+}
+
+/// Computes the number of elements in the given queue.
+///
+/// - Parameter handle: The handle to a queue.
+///
+/// - Output size: The number of elements in the given queue.
+@inlinable @inline(__always)
+public static func queueSizeV2(
+  handle: ResourceHandle
+) -> Tensor<Int32> {
+  let op = TFE_Op("QueueSizeV2")
+  let _ = op.addInput(handle)
+  return op.execute(Int(1))
+}
+
+/// Converts one or more images from RGB to HSV.
+///
+/// Outputs a tensor of the same shape as the `images` tensor, containing the HSV
+/// value of the pixels. The output is only well defined if the value in `images`
+/// are in `[0,1]`.
+///
+/// `output[..., 0]` contains hue, `output[..., 1]` contains saturation, and
+/// `output[..., 2]` contains value. All HSV values are in `[0,1]`. A hue of 0
+/// corresponds to pure red, hue 1/3 is pure green, and 2/3 is pure blue.
+///
+/// - Parameter images: 1-D or higher rank. RGB data to convert. Last dimension must be size 3.
+///
+/// - Output output: `images` converted to HSV.
+@inlinable @inline(__always)
+public static func rGBToHSV<T: FloatingPoint & TensorFlowScalar>(
+  images: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("RGBToHSV")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(images)
+  return op.execute(Int(1))
+}
+
+/// Gather ragged slices from `params` axis `0` according to `indices`.
+///
+/// Outputs a `RaggedTensor` output composed from `output_dense_values` and
+/// `output_nested_splits`, such that:
+///
+/// ```python
+/// output.shape = indices.shape + params.shape[1:]
+/// output.ragged_rank = indices.shape.ndims + params.ragged_rank
+/// output[i...j, d0...dn] = params[indices[i...j], d0...dn]
+/// ```
+///
+/// where
+///
+/// * `params =
+///    ragged.from_nested_row_splits(params_dense_values, params_nested_splits)`
+///    provides the values that should be gathered.
+/// * `indices` ia a dense tensor with dtype `int32` or `int64`, indicating which
+///    values should be gathered.
+/// * `output =
+///    ragged.from_nested_row_splits(output_dense_values, output_nested_splits)`
+///    is the output tensor.
+///
+/// (Note: This c++ op is used to implement the higher-level python
+/// `tf.ragged.gather` op, which also supports ragged indices.)
+///
+///
+/// - Parameters:
+///   - params_nested_splits: The `nested_row_splits` tensors that define the row-partitioning for the
+///     `params` RaggedTensor input.
+///   - params_dense_values: The `flat_values` for the `params` RaggedTensor. There was a terminology change
+///     at the python level from dense_values to flat_values, so dense_values is the
+///     deprecated name.
+///   - indices: Indices in the outermost dimension of `params` of the values that should be
+///     gathered.
+///
+/// - Attrs:
+///   - PARAMS_RAGGED_RANK: The ragged rank of the `params` RaggedTensor. `params_nested_splits` should
+///     contain this number of `row_splits` tensors. This value should equal
+///     `params.ragged_rank`.
+///   - OUTPUT_RAGGED_RANK: The ragged rank of the output RaggedTensor. `output_nested_splits` will contain
+///     this number of `row_splits` tensors. This value should equal
+///     `indices.shape.ndims + params.ragged_rank - 1`.
+///
+/// - Outputs:
+///   - output_nested_splits: The `nested_row_splits` tensors that define the row-partitioning for the
+///     returned RaggedTensor.
+///   - output_dense_values: The `flat_values` for the returned RaggedTensor.
+@inlinable @inline(__always)
+public static func raggedGather<
+    Tvalues: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  paramsNestedSplits: [Tensor<Int64>],
+  paramsDenseValues: Tensor<Tvalues>,
+  indices: Tensor<Tindices>,
+  oUTPUTRAGGEDRANK: Int64
+) -> (outputNestedSplits: [Tensor<Int64>], outputDenseValues: Tensor<Tvalues>) {
+  let op = TFE_Op("RaggedGather")
+  op.setAttr("Tvalues", Tvalues.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("PARAMS_RAGGED_RANK", paramsNestedSplits.count)
+  op.setAttr("OUTPUT_RAGGED_RANK", oUTPUTRAGGEDRANK)
+  let _ = op.addInputList(paramsNestedSplits)
+  let _ = op.addInput(paramsDenseValues)
+  let _ = op.addInput(indices)
+  return op.execute(Int(oUTPUTRAGGEDRANK), Int(1))
+}
+
+/// Returns a `RaggedTensor` containing the specified sequences of numbers.
+///
+///
+/// Returns a `RaggedTensor` `result` composed from `rt_dense_values` and
+/// `rt_nested_splits`, such that
+/// `result[i] = range(starts[i], limits[i], deltas[i])`.
+///
+/// ```python
+/// >>> (rt_nested_splits, rt_dense_values) = gen_ragged_ops.ragged_range(
+/// ...     starts=[2, 5, 8], limits=[3, 5, 12], deltas=1)
+/// >>> result = ragged.from_nested_row_splits(rt_dense_values, rt_nested_splits)
+/// >>> print result.eval().tolist()
+/// [[2],               # result[0] = range(2, 3)
+///  [],                # result[1] = range(5, 5)
+///  [8, 9, 10, 11]]    # result[2] = range(8, 12)
+/// ```
+///
+/// The input tensors `starts`, `limits`, and `deltas` may be scalars or vectors.
+/// The vector inputs must all have the same size.  Scalar inputs are broadcast
+/// to match the size of the vector inputs.
+///
+/// - Parameters:
+///   - starts: The starts of each range.
+///   - limits: The limits of each range.
+///   - deltas: The deltas of each range.
+///
+/// - Outputs:
+///   - rt_nested_splits: The `row_splits` for the returned `RaggedTensor`.
+///   - rt_dense_values: The `flat_values` for the returned `RaggedTensor`.
+@inlinable @inline(__always)
+public static func raggedRange<T: Numeric & TensorFlowScalar>(
+  starts: Tensor<T>,
+  limits: Tensor<T>,
+  deltas: Tensor<T>
+) -> (rtNestedSplits: Tensor<Int64>, rtDenseValues: Tensor<T>) {
+  let op = TFE_Op("RaggedRange")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(starts)
+  let _ = op.addInput(limits)
+  let _ = op.addInput(deltas)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Converts a `RaggedTensor` into a `SparseTensor` with the same values.
+///
+/// input=ragged.from_nested_row_splits(rt_dense_values, rt_nested_splits)
+/// output=SparseTensor(indices=sparse_indices, values=sparse_values,
+///                     dense_shape=sparse_dense_shape)
+///
+/// - Parameters:
+///   - rt_nested_splits: The `row_splits` for the `RaggedTensor`.
+///   - rt_dense_values: The `flat_values` for the `RaggedTensor`.
+///
+/// - Attr RAGGED_RANK: The ragged rank of the input RaggedTensor.  `rt_nested_splits` should contain
+///   this number of ragged-splits tensors.  This value should equal
+///   `input.ragged_rank`.
+///
+/// - Outputs:
+///   - sparse_indices: The indices for the `SparseTensor`.
+///   - sparse_values: The values of the `SparseTensor`.
+///   - sparse_dense_shape: `sparse_dense_shape` is a tight bounding box of the input `RaggedTensor`.
+@inlinable @inline(__always)
+public static func raggedTensorToSparse<T: TensorFlowScalar>(
+  rtNestedSplits: [Tensor<Int64>],
+  rtDenseValues: Tensor<T>
+) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<T>, sparseDenseShape: Tensor<Int64>) {
+  let op = TFE_Op("RaggedTensorToSparse")
+  op.setAttr("RAGGED_RANK", rtNestedSplits.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInputList(rtNestedSplits)
+  let _ = op.addInput(rtDenseValues)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Randomly crop `image`.
+///
+/// `size` is a 1-D int64 tensor with 2 elements representing the crop height and
+/// width.  The values must be non negative.
+///
+/// This Op picks a random location in `image` and crops a `height` by `width`
+/// rectangle from that location.  The random location is picked so the cropped
+/// area will fit inside the original image.
+///
+/// - Parameters:
+///   - image: 3-D of shape `[height, width, channels]`.
+///   - size: 1-D of length 2 containing: `crop_height`, `crop_width`..
+///
+/// - Attrs:
+///   - seed: If either seed or seed2 are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: An second seed to avoid seed collision.
+///
+/// - Output output: 3-D of shape `[crop_height, crop_width, channels].`
+@inlinable @inline(__always)
+public static func randomCrop<T: Numeric & TensorFlowScalar>(
+  image: Tensor<T>,
+  size: Tensor<Int64>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<T> {
+  let op = TFE_Op("RandomCrop")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(image)
+  let _ = op.addInput(size)
+  return op.execute(Int(1))
+}
+
+/// Outputs random values from the Gamma distribution(s) described by alpha.
+///
+/// This op uses the algorithm by Marsaglia et al. to acquire samples via
+/// transformation-rejection from pairs of uniform and normal random variables.
+/// See http://dl.acm.org/citation.cfm?id=358414
+///
+/// - Parameters:
+///   - shape: 1-D integer tensor. Shape of independent samples to draw from each
+///     distribution described by the shape parameters given in alpha.
+///   - alpha: A tensor in which each scalar is a "shape" parameter describing the
+///     associated gamma distribution.
+///
+/// - Attrs:
+///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: A second seed to avoid seed collision.
+///
+/// - Output output: A tensor with shape `shape + shape(alpha)`. Each slice
+///   `[:, ..., :, i0, i1, ...iN]` contains the samples drawn for
+///   `alpha[i0, i1, ...iN]`. The dtype of the output matches the dtype of alpha.
+@inlinable @inline(__always)
+public static func randomGamma<
+    S: BinaryInteger & TensorFlowScalar,
+    T: FloatingPoint & TensorFlowScalar
+>(
+  shape: Tensor<S>,
+  alpha: Tensor<T>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<T> {
+  let op = TFE_Op("RandomGamma")
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("S", S.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(alpha)
+  return op.execute(Int(1))
+}
+
+/// Computes the derivative of a Gamma random sample w.r.t. `alpha`.
+@inlinable @inline(__always)
+public static func randomGammaGrad<T: FloatingPoint & TensorFlowScalar>(
+  alpha: Tensor<T>,
+  sample: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("RandomGammaGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(alpha)
+  let _ = op.addInput(sample)
+  return op.execute(Int(1))
+}
+
+/// Use RandomPoissonV2 instead.
+@inlinable @inline(__always)
+public static func randomPoisson<
+    S: BinaryInteger & TensorFlowScalar,
+    Dtype: FloatingPoint & TensorFlowScalar
+>(
+  shape: Tensor<S>,
+  rate: Tensor<Dtype>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<Dtype> {
+  let op = TFE_Op("RandomPoisson")
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("S", S.tensorFlowDataType)
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(rate)
+  return op.execute(Int(1))
+}
+
+/// Outputs random values from the Poisson distribution(s) described by rate.
+///
+/// This op uses two algorithms, depending on rate. If rate >= 10, then
+/// the algorithm by Hormann is used to acquire samples via
+/// transformation-rejection.
+/// See http://www.sciencedirect.com/science/article/pii/0167668793909974.
+///
+/// Otherwise, Knuth's algorithm is used to acquire samples via multiplying uniform
+/// random variables.
+/// See Donald E. Knuth (1969). Seminumerical Algorithms. The Art of Computer
+/// Programming, Volume 2. Addison Wesley
+///
+/// - Parameters:
+///   - shape: 1-D integer tensor. Shape of independent samples to draw from each
+///     distribution described by the shape parameters given in rate.
+///   - rate: A tensor in which each scalar is a "rate" parameter describing the
+///     associated poisson distribution.
+///
+/// - Attrs:
+///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: A second seed to avoid seed collision.
+///
+/// - Output output: A tensor with shape `shape + shape(rate)`. Each slice
+///   `[:, ..., :, i0, i1, ...iN]` contains the samples drawn for
+///   `rate[i0, i1, ...iN]`.
+@inlinable @inline(__always)
+public static func randomPoissonV2<
+    S: BinaryInteger & TensorFlowScalar,
+    R: Numeric & TensorFlowScalar,
+    Dtype: Numeric & TensorFlowScalar
+>(
+  shape: Tensor<S>,
+  rate: Tensor<R>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<Dtype> {
+  let op = TFE_Op("RandomPoissonV2")
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("S", S.tensorFlowDataType)
+  op.setAttr("R", R.tensorFlowDataType)
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(rate)
+  return op.execute(Int(1))
+}
+
+/// Randomly shuffles a tensor along its first dimension.
+///
+///   The tensor is shuffled along dimension 0, such that each `value[j]` is mapped
+///   to one and only one `output[i]`. For example, a mapping that might occur for a
+///   3x2 tensor is:
+///
+/// ```
+/// [[1, 2],       [[5, 6],
+///  [3, 4],  ==>   [1, 2],
+///  [5, 6]]        [3, 4]]
+/// ```
+///
+/// - Parameter value: The tensor to be shuffled.
+///
+/// - Attrs:
+///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: A second seed to avoid seed collision.
+///
+/// - Output output: A tensor of same shape and type as `value`, shuffled along its first
+///   dimension.
+@inlinable @inline(__always)
+public static func randomShuffle<T: TensorFlowScalar>(
+  value: Tensor<T>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<T> {
+  let op = TFE_Op("RandomShuffle")
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(value)
+  return op.execute(Int(1))
+}
+
+/// A queue that randomizes the order of elements.
+///
+/// - Attrs:
+///   - component_types: The type of each component in a value.
+///   - shapes: The shape of each component in a value. The length of this attr must
+///     be either 0 or the same as the length of component_types. If the length of
+///     this attr is 0, the shapes of queue elements are not constrained, and
+///     only one element may be dequeued at a time.
+///   - capacity: The upper bound on the number of elements in this queue.
+///     Negative numbers mean no limit.
+///   - min_after_dequeue: Dequeue will block unless there would be this
+///     many elements after the dequeue or the queue is closed. This
+///     ensures a minimum level of mixing of elements.
+///   - seed: If either seed or seed2 is set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, a random seed is used.
+///   - seed2: A second seed to avoid seed collision.
+///   - container: If non-empty, this queue is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this queue will be shared under the given name
+///     across multiple sessions.
+///
+/// - Output handle: The handle to the queue.
+@inlinable @inline(__always)
+public static func randomShuffleQueueV2(
+  componentTypes: [TensorDataType],
+  shapes: [TensorShape?],
+  capacity: Int64 = -1,
+  minAfterDequeue: Int64 = 0,
+  seed: Int64 = 0,
+  seed2: Int64 = 0,
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("RandomShuffleQueueV2")
+  op.setAttr("component_types", componentTypes)
+  op.setAttr("shapes", shapes)
+  op.setAttr("capacity", capacity)
+  op.setAttr("min_after_dequeue", minAfterDequeue)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Outputs random values from a normal distribution.
+///
+/// The generated values will have mean 0 and standard deviation 1.
+///
+/// - Parameter shape: The shape of the output tensor.
+///
+/// - Attrs:
+///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: A second seed to avoid seed collision.
+///   - dtype: The type of the output.
+///
+/// - Output output: A tensor of the specified shape filled with random normal values.
+@inlinable @inline(__always)
+public static func randomStandardNormal<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar
+>(
+  shape: Tensor<T>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<Dtype> {
+  let op = TFE_Op("RandomStandardNormal")
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Outputs random values from a uniform distribution.
+///
+/// The generated values follow a uniform distribution in the range `[0, 1)`. The
+/// lower bound 0 is included in the range, while the upper bound 1 is excluded.
+///
+/// - Parameter shape: The shape of the output tensor.
+///
+/// - Attrs:
+///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: A second seed to avoid seed collision.
+///   - dtype: The type of the output.
+///
+/// - Output output: A tensor of the specified shape filled with uniform random values.
+@inlinable @inline(__always)
+public static func randomUniform<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar
+>(
+  shape: Tensor<T>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<Dtype> {
+  let op = TFE_Op("RandomUniform")
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Outputs random integers from a uniform distribution.
+///
+/// The generated values are uniform integers in the range `[minval, maxval)`.
+/// The lower bound `minval` is included in the range, while the upper bound
+/// `maxval` is excluded.
+///
+/// The random integers are slightly biased unless `maxval - minval` is an exact
+/// power of two.  The bias is small for values of `maxval - minval` significantly
+/// smaller than the range of the output (either `2^32` or `2^64`).
+///
+/// - Parameters:
+///   - shape: The shape of the output tensor.
+///   - minval: 0-D.  Inclusive lower bound on the generated integers.
+///   - maxval: 0-D.  Exclusive upper bound on the generated integers.
+///
+/// - Attrs:
+///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: A second seed to avoid seed collision.
+///
+/// - Output output: A tensor of the specified shape filled with uniform random integers.
+@inlinable @inline(__always)
+public static func randomUniformInt<
+    Tout: BinaryInteger & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar
+>(
+  shape: Tensor<T>,
+  minval: Tensor<Tout>,
+  maxval: Tensor<Tout>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<Tout> {
+  let op = TFE_Op("RandomUniformInt")
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("Tout", Tout.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(minval)
+  let _ = op.addInput(maxval)
+  return op.execute(Int(1))
+}
+
+/// Creates a sequence of numbers.
+///
+/// This operation creates a sequence of numbers that begins at `start` and
+/// extends by increments of `delta` up to but not including `limit`.
+///
+/// For example:
+///
+/// ```
+/// # 'start' is 3
+/// # 'limit' is 18
+/// # 'delta' is 3
+/// tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]
+/// ```
+///
+/// - Parameters:
+///   - start: 0-D (scalar). First entry in the sequence.
+///   - limit: 0-D (scalar). Upper limit of sequence, exclusive.
+///   - delta: 0-D (scalar). Optional. Default is 1. Number that increments `start`.
+///
+/// - Output output: 1-D.
+@inlinable @inline(__always)
+public static func range<Tidx: Numeric & TensorFlowScalar>(
+  start: Tensor<Tidx>,
+  limit: Tensor<Tidx>,
+  delta: Tensor<Tidx>
+) -> Tensor<Tidx> {
+  let op = TFE_Op("Range")
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(start)
+  let _ = op.addInput(limit)
+  let _ = op.addInput(delta)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset with a range of values. Corresponds to python's xrange.
+///
+/// - Parameters:
+///   - start: corresponds to start in python's xrange().
+///   - stop: corresponds to stop in python's xrange().
+///   - step: corresponds to step in python's xrange().
+@inlinable @inline(__always)
+public static func rangeDataset(
+  start: Tensor<Int64>,
+  stop: Tensor<Int64>,
+  step: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("RangeDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(start)
+  let _ = op.addInput(stop)
+  let _ = op.addInput(step)
+  return op.execute(Int(1))
+}
+
+/// Returns the rank of a tensor.
+///
+/// This operation returns an integer representing the rank of `input`.
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
+/// # shape of tensor 't' is [2, 2, 3]
+/// rank(t) ==> 3
+/// ```
+///
+/// **Note**: The rank of a tensor is not the same as the rank of a matrix. The rank
+/// of a tensor is the number of indices required to uniquely select each element
+/// of the tensor. Rank is also known as "order", "degree", or "ndims."
+@inlinable @inline(__always)
+public static func rank<T: TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<Int32> {
+  let op = TFE_Op("Rank")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Reads and outputs the entire contents of the input filename.
+@inlinable @inline(__always)
+public static func readFile(
+  filename: StringTensor
+) -> StringTensor {
+  let op = TFE_Op("ReadFile")
+  let _ = op.addInput(filename)
+  return op.execute(Int(1))
+}
+
+/// Reads the value of a variable.
+///
+/// The tensor returned by this operation is immutable.
+///
+/// The value returned by this operation is guaranteed to be influenced by all the
+/// writes on which this operation depends directly or indirectly, and to not be
+/// influenced by any of the writes which depend directly or indirectly on this
+/// operation.
+///
+/// - Parameter resource: handle to the resource in which to store the variable.
+///
+/// - Attr dtype: the dtype of the value.
+@inlinable @inline(__always)
+public static func readVariableOp<Dtype: TensorFlowScalar>(
+  resource: ResourceHandle
+) -> Tensor<Dtype> {
+  let op = TFE_Op("ReadVariableOp")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  return op.execute(Int(1))
+}
+
+/// Returns the number of records this Reader has produced.
+///
+/// This is the same as the number of ReaderRead executions that have
+/// succeeded.
+///
+/// - Parameter reader_handle: Handle to a Reader.
+@inlinable @inline(__always)
+public static func readerNumRecordsProducedV2(
+  readerHandle: ResourceHandle
+) -> Tensor<Int64> {
+  let op = TFE_Op("ReaderNumRecordsProducedV2")
+  let _ = op.addInput(readerHandle)
+  return op.execute(Int(1))
+}
+
+/// Returns the number of work units this Reader has finished processing.
+///
+/// - Parameter reader_handle: Handle to a Reader.
+@inlinable @inline(__always)
+public static func readerNumWorkUnitsCompletedV2(
+  readerHandle: ResourceHandle
+) -> Tensor<Int64> {
+  let op = TFE_Op("ReaderNumWorkUnitsCompletedV2")
+  let _ = op.addInput(readerHandle)
+  return op.execute(Int(1))
+}
+
+/// Returns up to `num_records` (key, value) pairs produced by a Reader.
+///
+/// Will dequeue from the input queue if necessary (e.g. when the
+/// Reader needs to start reading from a new file since it has finished
+/// with the previous file).
+/// It may return less than `num_records` even before the last batch.
+///
+/// - Parameters:
+///   - reader_handle: Handle to a `Reader`.
+///   - queue_handle: Handle to a `Queue`, with string work items.
+///   - num_records: number of records to read from `Reader`.
+///
+/// - Outputs:
+///   - keys: A 1-D tensor.
+///   - values: A 1-D tensor.
+@inlinable @inline(__always)
+public static func readerReadUpToV2(
+  readerHandle: ResourceHandle,
+  queueHandle: ResourceHandle,
+  numRecords: Tensor<Int64>
+) -> (keys: StringTensor, values: StringTensor) {
+  let op = TFE_Op("ReaderReadUpToV2")
+  let _ = op.addInput(readerHandle)
+  let _ = op.addInput(queueHandle)
+  let _ = op.addInput(numRecords)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Returns the next record (key, value pair) produced by a Reader.
+///
+/// Will dequeue from the input queue if necessary (e.g. when the
+/// Reader needs to start reading from a new file since it has finished
+/// with the previous file).
+///
+/// - Parameters:
+///   - reader_handle: Handle to a Reader.
+///   - queue_handle: Handle to a Queue, with string work items.
+///
+/// - Outputs:
+///   - key: A scalar.
+///   - value: A scalar.
+@inlinable @inline(__always)
+public static func readerReadV2(
+  readerHandle: ResourceHandle,
+  queueHandle: ResourceHandle
+) -> (key: StringTensor, value: StringTensor) {
+  let op = TFE_Op("ReaderReadV2")
+  let _ = op.addInput(readerHandle)
+  let _ = op.addInput(queueHandle)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Restore a Reader to its initial clean state.
+///
+/// - Parameter reader_handle: Handle to a Reader.
+@inlinable @inline(__always)
+public static func readerResetV2(
+  readerHandle: ResourceHandle
+) {
+  let op = TFE_Op("ReaderResetV2")
+  let _ = op.addInput(readerHandle)
+  op.execute()
+}
+
+/// Restore a reader to a previously saved state.
+///
+/// Not all Readers support being restored, so this can produce an
+/// Unimplemented error.
+///
+/// - Parameters:
+///   - reader_handle: Handle to a Reader.
+///   - state: Result of a ReaderSerializeState of a Reader with type
+///     matching reader_handle.
+@inlinable @inline(__always)
+public static func readerRestoreStateV2(
+  readerHandle: ResourceHandle,
+  state: StringTensor
+) {
+  let op = TFE_Op("ReaderRestoreStateV2")
+  let _ = op.addInput(readerHandle)
+  let _ = op.addInput(state)
+  op.execute()
+}
+
+/// Produce a string tensor that encodes the state of a Reader.
+///
+/// Not all Readers support being serialized, so this can produce an
+/// Unimplemented error.
+///
+/// - Parameter reader_handle: Handle to a Reader.
+@inlinable @inline(__always)
+public static func readerSerializeStateV2(
+  readerHandle: ResourceHandle
+) -> StringTensor {
+  let op = TFE_Op("ReaderSerializeStateV2")
+  let _ = op.addInput(readerHandle)
+  return op.execute(Int(1))
+}
+
+/// Returns the real part of a complex number.
+///
+/// Given a tensor `input` of complex numbers, this operation returns a tensor of
+/// type `float` that is the real part of each element in `input`. All elements in
+/// `input` must be complex numbers of the form \\(a + bj\\), where *a* is the real
+///  part returned by this operation and *b* is the imaginary part.
+///
+/// For example:
+///
+/// ```
+/// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
+/// tf.real(input) ==> [-2.25, 3.25]
+/// ```
+@inlinable @inline(__always)
+public static func real<
+    T: TensorFlowScalar,
+    Tout: FloatingPoint & TensorFlowScalar
+>(
+  _ input: Tensor<T>
+) -> Tensor<Tout> {
+  let op = TFE_Op("Real")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tout", Tout.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Returns x / y element-wise for real types.
+///
+/// If `x` and `y` are reals, this will return the floating-point division.
+///
+/// *NOTE*: `Div` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func realDiv<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("RealDiv")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Computes the reciprocal of x element-wise.
+///
+/// I.e., \\(y = 1 / x\\).
+@inlinable @inline(__always)
+public static func reciprocal<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Reciprocal")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient for the inverse of `x` wrt its input.
+///
+/// Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy`
+/// is the corresponding input gradient.
+@inlinable @inline(__always)
+public static func reciprocalGrad<T: FloatingPoint & TensorFlowScalar>(
+  _ y: Tensor<T>,
+  dy: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("ReciprocalGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(y)
+  let _ = op.addInput(dy)
+  return op.execute(Int(1))
+}
+
+/// Emits randomized records.
+///
+/// - Attrs:
+///   - file_pattern: Glob pattern for the data files.
+///   - file_random_seed: Random seeds used to produce randomized records.
+///   - file_shuffle_shift_ratio: Shifts the list of files after the list is randomly
+///     shuffled.
+///   - file_buffer_size: The randomization shuffling buffer.
+///   - file_parallelism: How many sstables are opened and concurrently iterated over.
+///   - batch_size: The batch size.
+///   - compression_type: The type of compression for the file. Currently ZLIB and
+///     GZIP are supported. Defaults to none.
+///
+/// - Output records: A tensor of shape [batch_size].
+@inlinable @inline(__always)
+public static func recordInput(
+  filePattern: String,
+  fileRandomSeed: Int64 = 301,
+  fileShuffleShiftRatio: Double = 0,
+  fileBufferSize: Int64 = 10000,
+  fileParallelism: Int64 = 16,
+  batchSize: Int64 = 32,
+  compressionType: String
+) -> StringTensor {
+  let op = TFE_Op("RecordInput")
+  op.setAttr("file_pattern", filePattern)
+  op.setAttr("file_random_seed", fileRandomSeed)
+  op.setAttr("file_shuffle_shift_ratio", fileShuffleShiftRatio)
+  op.setAttr("file_buffer_size", fileBufferSize)
+  op.setAttr("file_parallelism", fileParallelism)
+  op.setAttr("batch_size", batchSize)
+  op.setAttr("compression_type", compressionType)
+  return op.execute(Int(1))
+}
+
+/// An op that receives embedding activations on the TPU.
+///
+/// The TPU system performs the embedding lookups and aggregations specified by
+/// the arguments to TPUEmbeddingEnqueue(Integer/Sparse/SparseTensor)Batch. The
+/// results of these aggregations are visible to the Tensorflow Graph as the
+/// outputs of a RecvTPUEmbeddingActivations op. This op returns a list containing
+/// one Tensor of activations per table specified in the model. There can be at
+/// most one RecvTPUEmbeddingActivations op in the TPU graph.
+///
+/// - Attrs:
+///   - num_outputs: The number of output activation tensors, equal to the number of
+///     embedding tables in the model.
+///   - config: Serialized TPUEmbeddingConfiguration proto.
+///
+/// - Output outputs: A TensorList of embedding activations containing one Tensor per
+///   embedding table in the model.
+@inlinable @inline(__always)
+public static func recvTPUEmbeddingActivations(
+  numOutputs: Int64,
+  config: String
+) -> [Tensor<Float>] {
+  let op = TFE_Op("RecvTPUEmbeddingActivations")
+  op.setAttr("num_outputs", numOutputs)
+  op.setAttr("config", config)
+  return op.execute(Int(numOutputs))
+}
+
+/// Reduces the input dataset to a singleton using a reduce function.
+///
+/// - Parameters:
+///   - input_dataset: A variant tensor representing the input dataset.
+///   - initial_state: A nested structure of tensors, representing the initial state of the
+///     transformation.
+///
+/// - Attr f: A function that maps `(old_state, input_element)` to `new_state`. It must take
+///   two arguments and return a nested structures of tensors. The structure of
+///   `new_state` must match the structure of `initial_state`.
+@inlinable @inline(__always)
+public static func reduceDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Tstate: TensorArrayProtocol,
+    Targuments: TensorArrayProtocol,
+    OutputTypes: TensorGroup
+>(
+  inputDataset: VariantHandle,
+  initialState: Tstate,
+  otherArguments: Targuments,
+  f: (FIn) -> FOut,
+  outputShapes: [TensorShape?],
+  useInterOpParallelism: Bool = true
+) -> OutputTypes {
+  let op = TFE_Op("ReduceDataset")
+  op.setAttr("f", f)
+  op.setAttr("Tstate", initialState._typeList)
+  op.setAttr("Targuments", otherArguments._typeList)
+  op.setAttr("output_types", OutputTypes._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("use_inter_op_parallelism", useInterOpParallelism)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInputList(initialState)
+  let _ = op.addInputList(otherArguments)
+  return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Joins a string Tensor across the given dimensions.
+///
+/// Computes the string join across dimensions in the given string Tensor of shape
+/// `[\\(d_0, d_1, ..., d_{n-1}\\)]`.  Returns a new Tensor created by joining the input
+/// strings with the given separator (default: empty string).  Negative indices are
+/// counted backwards from the end, with `-1` being equivalent to `n - 1`.  If
+/// indices are not specified, joins across all dimensions beginning from `n - 1`
+/// through `0`.
+///
+/// For example:
+///
+/// ```python
+/// # tensor `a` is [["a", "b"], ["c", "d"]]
+/// tf.reduce_join(a, 0) ==> ["ac", "bd"]
+/// tf.reduce_join(a, 1) ==> ["ab", "cd"]
+/// tf.reduce_join(a, -2) = tf.reduce_join(a, 0) ==> ["ac", "bd"]
+/// tf.reduce_join(a, -1) = tf.reduce_join(a, 1) ==> ["ab", "cd"]
+/// tf.reduce_join(a, 0, keep_dims=True) ==> [["ac", "bd"]]
+/// tf.reduce_join(a, 1, keep_dims=True) ==> [["ab"], ["cd"]]
+/// tf.reduce_join(a, 0, separator=".") ==> ["a.c", "b.d"]
+/// tf.reduce_join(a, [0, 1]) ==> "acbd"
+/// tf.reduce_join(a, [1, 0]) ==> "abcd"
+/// tf.reduce_join(a, []) ==> [["a", "b"], ["c", "d"]]
+/// tf.reduce_join(a) = tf.reduce_join(a, [1, 0]) ==> "abcd"
+/// ```
+///
+/// - Parameters:
+///   - inputs: The input to be joined.  All reduced indices must have non-zero size.
+///   - reduction_indices: The dimensions to reduce over.  Dimensions are reduced in the
+///     order specified.  Omitting `reduction_indices` is equivalent to passing
+///     `[n-1, n-2, ..., 0]`.  Negative indices from `-n` to `-1` are supported.
+///
+/// - Attrs:
+///   - keep_dims: If `True`, retain reduced dimensions with length `1`.
+///   - separator: The separator to use when joining.
+///
+/// - Output output: Has shape equal to that of the input with reduced dimensions removed or
+///   set to `1` depending on `keep_dims`.
+@inlinable @inline(__always)
+public static func reduceJoin(
+  inputs: StringTensor,
+  reductionIndices: Tensor<Int32>,
+  keepDims: Bool = false,
+  separator: String
+) -> StringTensor {
+  let op = TFE_Op("ReduceJoin")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("separator", separator)
+  let _ = op.addInput(inputs)
+  let _ = op.addInput(reductionIndices)
+  return op.execute(Int(1))
+}
+
+/// Check if the input matches the regex pattern.
+///
+/// The input is a string tensor of any shape. The pattern is a scalar
+/// string tensor which is applied to every element of the input tensor.
+/// The boolean values (True or False) of the output tensor indicate
+/// if the input matches the regex pattern provided.
+///
+/// The pattern follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
+///
+/// - Parameters:
+///   - input: A string tensor of the text to be processed.
+///   - pattern: A scalar string tensor containing the regular expression to match the input.
+///
+/// - Output output: A bool tensor with the same shape as `input`.
+@inlinable @inline(__always)
+public static func regexFullMatch(
+  _ input: StringTensor,
+  pattern: StringTensor
+) -> Tensor<Bool> {
+  let op = TFE_Op("RegexFullMatch")
+  let _ = op.addInput(input)
+  let _ = op.addInput(pattern)
+  return op.execute(Int(1))
+}
+
+/// Replaces matches of the `pattern` regular expression in `input` with the
+/// replacement string provided in `rewrite`.
+///
+/// It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
+///
+/// - Parameters:
+///   - input: The text to be processed.
+///   - pattern: The regular expression to be matched in the `input` strings.
+///   - rewrite: The rewrite string to be substituted for the `pattern` expression where it is
+///     matched in the `input` strings.
+///
+/// - Attr replace_global: If True, the replacement is global (that is, all matches of the `pattern` regular
+///   expression in each input string are rewritten), otherwise the `rewrite`
+///   substitution is only made for the first `pattern` match.
+///
+/// - Output output: The text after applying pattern match and rewrite substitution.
+@inlinable @inline(__always)
+public static func regexReplace(
+  _ input: StringTensor,
+  pattern: StringTensor,
+  rewrite: StringTensor,
+  replaceGlobal: Bool = true
+) -> StringTensor {
+  let op = TFE_Op("RegexReplace")
+  op.setAttr("replace_global", replaceGlobal)
+  let _ = op.addInput(input)
+  let _ = op.addInput(pattern)
+  let _ = op.addInput(rewrite)
+  return op.execute(Int(1))
+}
+
+/// Computes rectified linear: `max(features, 0)`.
+@inlinable @inline(__always)
+public static func relu<T: Numeric & TensorFlowScalar>(
+  features: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Relu")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(features)
+  return op.execute(Int(1))
+}
+
+/// Computes rectified linear 6: `min(max(features, 0), 6)`.
+@inlinable @inline(__always)
+public static func relu6<T: Numeric & TensorFlowScalar>(
+  features: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Relu6")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(features)
+  return op.execute(Int(1))
+}
+
+/// Computes rectified linear 6 gradients for a Relu6 operation.
+///
+/// - Parameters:
+///   - gradients: The backpropagated gradients to the corresponding Relu6 operation.
+///   - features: The features passed as input to the corresponding Relu6 operation, or
+///     its output; using either one produces the same result.
+///
+/// - Output backprops: The gradients:
+///   `gradients * (features > 0) * (features < 6)`.
+@inlinable @inline(__always)
+public static func relu6Grad<T: Numeric & TensorFlowScalar>(
+  gradients: Tensor<T>,
+  features: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Relu6Grad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(gradients)
+  let _ = op.addInput(features)
+  return op.execute(Int(1))
+}
+
+/// Computes rectified linear gradients for a Relu operation.
+///
+/// - Parameters:
+///   - gradients: The backpropagated gradients to the corresponding Relu operation.
+///   - features: The features passed as input to the corresponding Relu operation, OR
+///     the outputs of that operation (both work equivalently).
+///
+/// - Output backprops: `gradients * (features > 0)`.
+@inlinable @inline(__always)
+public static func reluGrad<T: Numeric & TensorFlowScalar>(
+  gradients: Tensor<T>,
+  features: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("ReluGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(gradients)
+  let _ = op.addInput(features)
+  return op.execute(Int(1))
+}
+
+/// Runs function `f` on a remote device indicated by `target`.
+///
+/// - Parameters:
+///   - target: A fully specified device name where we want to run the function.
+///   - args: A list of arguments for the function.
+///
+/// - Attrs:
+///   - Tin: The type list for the arguments.
+///   - Tout: The type list for the return values.
+///   - f: The function to run remotely.
+///
+/// - Output output: A list of return values.
+@inlinable @inline(__always)
+public static func remoteCall<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    FIn: TensorGroup,
+    FOut: TensorGroup
+>(
+  target: StringTensor,
+  args: Tin,
+  f: (FIn) -> FOut
+) -> Tout {
+  let op = TFE_Op("RemoteCall")
+  op.setAttr("Tin", args._typeList)
+  op.setAttr("Tout", Tout._typeList)
+  op.setAttr("f", f)
+  let _ = op.addInput(target)
+  let _ = op.addInputList(args)
+  return op.execute(Int(Tout._typeList.count))
+}
+
+/// Execute a sub graph on a remote processor.
+///
+/// The graph specifications(such as graph itself, input tensors and output names)
+/// are stored as a serialized protocol buffer of RemoteFusedGraphExecuteInfo
+/// as serialized_remote_fused_graph_execute_info.
+/// The specifications will be passed to a dedicated registered
+/// remote fused graph executor.  The executor will send the graph specifications
+/// to a remote processor and execute that graph.  The execution results
+/// will be passed to consumer nodes as outputs of this node.
+///
+/// - Parameter inputs: Arbitrary number of tensors with arbitrary data types
+///
+/// - Attr serialized_remote_fused_graph_execute_info: Serialized protocol buffer
+///   of RemoteFusedGraphExecuteInfo which contains graph specifications.
+///
+/// - Output outputs: Arbitrary number of tensors with arbitrary data types
+@inlinable @inline(__always)
+public static func remoteFusedGraphExecute<
+    Tinputs: TensorArrayProtocol,
+    Toutputs: TensorGroup
+>(
+  inputs: Tinputs,
+  serializedRemoteFusedGraphExecuteInfo: String
+) -> Toutputs {
+  let op = TFE_Op("RemoteFusedGraphExecute")
+  op.setAttr("Tinputs", inputs._typeList)
+  op.setAttr("Toutputs", Toutputs._typeList)
+  op.setAttr("serialized_remote_fused_graph_execute_info", serializedRemoteFusedGraphExecuteInfo)
+  let _ = op.addInputList(inputs)
+  return op.execute(Int(Toutputs._typeList.count))
+}
+
+/// Creates a dataset that emits the outputs of `input_dataset` `count` times.
+///
+/// - Parameter count: A scalar representing the number of times that `input_dataset` should
+///   be repeated. A value of `-1` indicates that it should be repeated infinitely.
+@inlinable @inline(__always)
+public static func repeatDataset(
+  inputDataset: VariantHandle,
+  count: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("RepeatDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(count)
+  return op.execute(Int(1))
+}
+
+/// Computes a range that covers the actual values present in a quantized tensor.
+///
+/// Given a quantized tensor described by `(input, input_min, input_max)`, outputs a
+/// range that covers the actual values present in that tensor. This op is typically
+/// used to produce the `requested_output_min` and `requested_output_max` for
+/// `Requantize`.
+///
+/// - Parameters:
+///   - input_min: The float value that the minimum quantized input value represents.
+///   - input_max: The float value that the maximum quantized input value represents.
+///
+/// - Attr Tinput: The type of the input.
+///
+/// - Outputs:
+///   - output_min: The computed min output.
+///   - output_max: the computed max output.
+@inlinable @inline(__always)
+public static func requantizationRange<Tinput: TensorFlowScalar>(
+  _ input: Tensor<Tinput>,
+  inputMin: Tensor<Float>,
+  inputMax: Tensor<Float>
+) -> (outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let op = TFE_Op("RequantizationRange")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputMin)
+  let _ = op.addInput(inputMax)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Computes requantization range per channel.
+///
+/// - Parameters:
+///   - input: The original input tensor.
+///   - input_min: The minimum value of the input tensor
+///   - input_max: The maximum value of the input tensor.
+///
+/// - Attrs:
+///   - T: The quantized type of input tensor that needs to be converted. 
+///   - clip_value_max: The maximum value of the output that needs to be clipped.
+///     Example: set this to 6 for Relu6. 
+///
+/// - Outputs:
+///   - output_min: The minimum value of the final output tensor
+///   - output_max: The maximum value of the final output tensor.
+@inlinable @inline(__always)
+public static func requantizationRangePerChannel<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  inputMin: Tensor<Float>,
+  inputMax: Tensor<Float>,
+  clipValueMax: Double
+) -> (outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let op = TFE_Op("RequantizationRangePerChannel")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("clip_value_max", clipValueMax)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputMin)
+  let _ = op.addInput(inputMax)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Converts the quantized `input` tensor into a lower-precision `output`.
+///
+/// Converts the quantized `input` tensor into a lower-precision `output`, using the
+/// output range specified with `requested_output_min` and `requested_output_max`.
+///
+/// `[input_min, input_max]` are scalar floats that specify the range for the float
+/// interpretation of the `input` data. For example, if `input_min` is -1.0f and
+/// `input_max` is 1.0f, and we are dealing with `quint16` quantized data, then a 0
+/// value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.
+///
+/// - Parameters:
+///   - input_min: The float value that the minimum quantized input value represents.
+///   - input_max: The float value that the maximum quantized input value represents.
+///   - requested_output_min: The float value that the minimum quantized output value represents.
+///   - requested_output_max: The float value that the maximum quantized output value represents.
+///
+/// - Attrs:
+///   - Tinput: The type of the input.
+///   - out_type: The type of the output. Should be a lower bit depth than Tinput.
+///
+/// - Outputs:
+///   - output_min: The requested_output_min value is copied into this output.
+///   - output_max: The requested_output_max value is copied into this output.
+@inlinable @inline(__always)
+public static func requantize<
+    Tinput: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<Tinput>,
+  inputMin: Tensor<Float>,
+  inputMax: Tensor<Float>,
+  requestedOutputMin: Tensor<Float>,
+  requestedOutputMax: Tensor<Float>
+) -> (output: Tensor<OutType>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let op = TFE_Op("Requantize")
+  op.setAttr("Tinput", Tinput.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputMin)
+  let _ = op.addInput(inputMax)
+  let _ = op.addInput(requestedOutputMin)
+  let _ = op.addInput(requestedOutputMax)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Requantizes input with min and max values known per channel.
+///
+/// - Parameters:
+///   - input: The original input tensor.
+///   - input_min: The minimum value of the input tensor
+///   - input_max: The maximum value of the input tensor.
+///   - requested_output_min: The minimum value of the output tensor requested.
+///   - requested_output_max: The maximum value of the output tensor requested.
+///
+/// - Attrs:
+///   - T: The quantized type of input tensor that needs to be converted. 
+///   - out_type: The quantized type of output tensor that needs to be converted.
+///
+/// - Outputs:
+///   - output: Output tensor.
+///   - output_min: The minimum value of the final output tensor
+///   - output_max: The maximum value of the final output tensor.
+@inlinable @inline(__always)
+public static func requantizePerChannel<
+    T: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  inputMin: Tensor<Float>,
+  inputMax: Tensor<Float>,
+  requestedOutputMin: Tensor<Float>,
+  requestedOutputMax: Tensor<Float>
+) -> (output: Tensor<OutType>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let op = TFE_Op("RequantizePerChannel")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(inputMin)
+  let _ = op.addInput(inputMax)
+  let _ = op.addInput(requestedOutputMin)
+  let _ = op.addInput(requestedOutputMax)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func requiresOlderGraphVersion(
+) -> Tensor<Int32> {
+  let op = TFE_Op("RequiresOlderGraphVersion")
+  
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func reservedAttr(
+  range: Int64
+) {
+  let op = TFE_Op("ReservedAttr")
+  op.setAttr("range", range)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func reservedInput(
+  _ input: Tensor<Int32>
+) {
+  let op = TFE_Op("ReservedInput")
+  let _ = op.addInput(input)
+  op.execute()
+}
+
+/// Reshapes a tensor.
+///
+/// Given `tensor`, this operation returns a tensor that has the same values
+/// as `tensor` with shape `shape`.
+///
+/// If one component of `shape` is the special value -1, the size of that dimension
+/// is computed so that the total size remains constant.  In particular, a `shape`
+/// of `[-1]` flattens into 1-D.  At most one component of `shape` can be -1.
+///
+/// If `shape` is 1-D or higher, then the operation returns a tensor with shape
+/// `shape` filled with the values of `tensor`. In this case, the number of elements
+/// implied by `shape` must be the same as the number of elements in `tensor`.
+///
+/// For example:
+///
+/// ```
+/// # tensor 't' is [1, 2, 3, 4, 5, 6, 7, 8, 9]
+/// # tensor 't' has shape [9]
+/// reshape(t, [3, 3]) ==> [[1, 2, 3],
+///                         [4, 5, 6],
+///                         [7, 8, 9]]
+///
+/// # tensor 't' is [[[1, 1], [2, 2]],
+/// #                [[3, 3], [4, 4]]]
+/// # tensor 't' has shape [2, 2, 2]
+/// reshape(t, [2, 4]) ==> [[1, 1, 2, 2],
+///                         [3, 3, 4, 4]]
+///
+/// # tensor 't' is [[[1, 1, 1],
+/// #                 [2, 2, 2]],
+/// #                [[3, 3, 3],
+/// #                 [4, 4, 4]],
+/// #                [[5, 5, 5],
+/// #                 [6, 6, 6]]]
+/// # tensor 't' has shape [3, 2, 3]
+/// # pass '[-1]' to flatten 't'
+/// reshape(t, [-1]) ==> [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]
+///
+/// # -1 can also be used to infer the shape
+///
+/// # -1 is inferred to be 9:
+/// reshape(t, [2, -1]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
+///                          [4, 4, 4, 5, 5, 5, 6, 6, 6]]
+/// # -1 is inferred to be 2:
+/// reshape(t, [-1, 9]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
+///                          [4, 4, 4, 5, 5, 5, 6, 6, 6]]
+/// # -1 is inferred to be 3:
+/// reshape(t, [ 2, -1, 3]) ==> [[[1, 1, 1],
+///                               [2, 2, 2],
+///                               [3, 3, 3]],
+///                              [[4, 4, 4],
+///                               [5, 5, 5],
+///                               [6, 6, 6]]]
+///
+/// # tensor 't' is [7]
+/// # shape `[]` reshapes to a scalar
+/// reshape(t, []) ==> 7
+/// ```
+///
+/// - Parameter shape: Defines the shape of the output tensor.
+@inlinable @inline(__always)
+public static func reshape<
+    T: TensorFlowScalar,
+    Tshape: BinaryInteger & TensorFlowScalar
+>(
+  _ tensor: Tensor<T>,
+  shape: Tensor<Tshape>
+) -> Tensor<T> {
+  let op = TFE_Op("Reshape")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tshape", Tshape.tensorFlowDataType)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Resize `images` to `size` using area interpolation.
+///
+/// Input images can be of different types but output images are always float.
+///
+/// The range of pixel values for the output image might be slightly different
+/// from the range for the input image because of limited numerical precision.
+/// To guarantee an output range, for example `[0.0, 1.0]`, apply
+/// `tf.clip_by_value` to the output.
+///
+/// Each output pixel is computed by first transforming the pixel's footprint into
+/// the input tensor and then averaging the pixels that intersect the footprint. An
+/// input pixel's contribution to the average is weighted by the fraction of its
+/// area that intersects the footprint.  This is the same as OpenCV's INTER_AREA.
+///
+/// - Parameters:
+///   - images: 4-D with shape `[batch, height, width, channels]`.
+///   - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+///     new size for the images.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
+///   aligned, preserving the values at the corner pixels. Defaults to false.
+///
+/// - Output resized_images: 4-D with shape
+///   `[batch, new_height, new_width, channels]`.
+@inlinable @inline(__always)
+public static func resizeArea<T: Numeric & TensorFlowScalar>(
+  images: Tensor<T>,
+  size: Tensor<Int32>,
+  alignCorners: Bool = false
+) -> Tensor<Float> {
+  let op = TFE_Op("ResizeArea")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("align_corners", alignCorners)
+  let _ = op.addInput(images)
+  let _ = op.addInput(size)
+  return op.execute(Int(1))
+}
+
+/// Resize `images` to `size` using bicubic interpolation.
+///
+/// Input images can be of different types but output images are always float.
+///
+/// - Parameters:
+///   - images: 4-D with shape `[batch, height, width, channels]`.
+///   - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+///     new size for the images.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
+///   aligned, preserving the values at the corner pixels. Defaults to false.
+///
+/// - Output resized_images: 4-D with shape
+///   `[batch, new_height, new_width, channels]`.
+@inlinable @inline(__always)
+public static func resizeBicubic<T: Numeric & TensorFlowScalar>(
+  images: Tensor<T>,
+  size: Tensor<Int32>,
+  alignCorners: Bool = false,
+  halfPixelCenters: Bool = false
+) -> Tensor<Float> {
+  let op = TFE_Op("ResizeBicubic")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("align_corners", alignCorners)
+  op.setAttr("half_pixel_centers", halfPixelCenters)
+  let _ = op.addInput(images)
+  let _ = op.addInput(size)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient of bicubic interpolation.
+///
+/// - Parameters:
+///   - grads: 4-D with shape `[batch, height, width, channels]`.
+///   - original_image: 4-D with shape `[batch, orig_height, orig_width, channels]`,
+///     The image tensor that was resized.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and grad tensors are
+///   aligned. Defaults to false.
+///
+/// - Output output: 4-D with shape `[batch, orig_height, orig_width, channels]`.
+///   Gradients with respect to the input image. Input image must have been
+///   float or double.
+@inlinable @inline(__always)
+public static func resizeBicubicGrad<T: FloatingPoint & TensorFlowScalar>(
+  grads: Tensor<Float>,
+  originalImage: Tensor<T>,
+  alignCorners: Bool = false,
+  halfPixelCenters: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("ResizeBicubicGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("align_corners", alignCorners)
+  op.setAttr("half_pixel_centers", halfPixelCenters)
+  let _ = op.addInput(grads)
+  let _ = op.addInput(originalImage)
+  return op.execute(Int(1))
+}
+
+/// Resize `images` to `size` using bilinear interpolation.
+///
+/// Input images can be of different types but output images are always float.
+///
+/// - Parameters:
+///   - images: 4-D with shape `[batch, height, width, channels]`.
+///   - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+///     new size for the images.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
+///   aligned, preserving the values at the corner pixels. Defaults to false.
+///
+/// - Output resized_images: 4-D with shape
+///   `[batch, new_height, new_width, channels]`.
+@inlinable @inline(__always)
+public static func resizeBilinear<T: Numeric & TensorFlowScalar>(
+  images: Tensor<T>,
+  size: Tensor<Int32>,
+  alignCorners: Bool = false,
+  halfPixelCenters: Bool = false
+) -> Tensor<Float> {
+  let op = TFE_Op("ResizeBilinear")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("align_corners", alignCorners)
+  op.setAttr("half_pixel_centers", halfPixelCenters)
+  let _ = op.addInput(images)
+  let _ = op.addInput(size)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient of bilinear interpolation.
+///
+/// - Parameters:
+///   - grads: 4-D with shape `[batch, height, width, channels]`.
+///   - original_image: 4-D with shape `[batch, orig_height, orig_width, channels]`,
+///     The image tensor that was resized.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and grad tensors are
+///   aligned. Defaults to false.
+///
+/// - Output output: 4-D with shape `[batch, orig_height, orig_width, channels]`.
+///   Gradients with respect to the input image. Input image must have been
+///   float or double.
+@inlinable @inline(__always)
+public static func resizeBilinearGrad<T: FloatingPoint & TensorFlowScalar>(
+  grads: Tensor<Float>,
+  originalImage: Tensor<T>,
+  alignCorners: Bool = false,
+  halfPixelCenters: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("ResizeBilinearGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("align_corners", alignCorners)
+  op.setAttr("half_pixel_centers", halfPixelCenters)
+  let _ = op.addInput(grads)
+  let _ = op.addInput(originalImage)
+  return op.execute(Int(1))
+}
+
+/// Resize `images` to `size` using nearest neighbor interpolation.
+///
+/// - Parameters:
+///   - images: 4-D with shape `[batch, height, width, channels]`.
+///   - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+///     new size for the images.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
+///   aligned, preserving the values at the corner pixels. Defaults to false.
+///
+/// - Output resized_images: 4-D with shape
+///   `[batch, new_height, new_width, channels]`.
+@inlinable @inline(__always)
+public static func resizeNearestNeighbor<T: Numeric & TensorFlowScalar>(
+  images: Tensor<T>,
+  size: Tensor<Int32>,
+  alignCorners: Bool = false,
+  halfPixelCenters: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("ResizeNearestNeighbor")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("align_corners", alignCorners)
+  op.setAttr("half_pixel_centers", halfPixelCenters)
+  let _ = op.addInput(images)
+  let _ = op.addInput(size)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient of nearest neighbor interpolation.
+///
+/// - Parameters:
+///   - grads: 4-D with shape `[batch, height, width, channels]`.
+///   - size: = A 1-D int32 Tensor of 2 elements: `orig_height, orig_width`. The
+///     original input size.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and grad tensors are
+///   aligned. Defaults to false.
+///
+/// - Output output: 4-D with shape `[batch, orig_height, orig_width, channels]`. Gradients
+///   with respect to the input image.
+@inlinable @inline(__always)
+public static func resizeNearestNeighborGrad<T: Numeric & TensorFlowScalar>(
+  grads: Tensor<T>,
+  size: Tensor<Int32>,
+  alignCorners: Bool = false,
+  halfPixelCenters: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("ResizeNearestNeighborGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("align_corners", alignCorners)
+  op.setAttr("half_pixel_centers", halfPixelCenters)
+  let _ = op.addInput(grads)
+  let _ = op.addInput(size)
+  return op.execute(Int(1))
+}
+
+/// Update '*var' according to the AdaMax algorithm.
+///
+/// m_t <- beta1 * m_{t-1} + (1 - beta1) * g
+/// v_t <- max(beta2 * v_{t-1}, abs(g))
+/// variable <- variable - learning_rate / (1 - beta1^t) * m_t / (v_t + epsilon)
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - m: Should be from a Variable().
+///   - v: Should be from a Variable().
+///   - beta1_power: Must be a scalar.
+///   - lr: Scaling factor. Must be a scalar.
+///   - beta1: Momentum factor. Must be a scalar.
+///   - beta2: Momentum factor. Must be a scalar.
+///   - epsilon: Ridge term. Must be a scalar.
+///   - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var, m, and v tensors will be protected
+///   by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceApplyAdaMax<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  m: ResourceHandle,
+  v: ResourceHandle,
+  beta1Power: Tensor<T>,
+  lr: Tensor<T>,
+  beta1: Tensor<T>,
+  beta2: Tensor<T>,
+  epsilon: Tensor<T>,
+  grad: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyAdaMax")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(m)
+  let _ = op.addInput(v)
+  let _ = op.addInput(beta1Power)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(beta1)
+  let _ = op.addInput(beta2)
+  let _ = op.addInput(epsilon)
+  let _ = op.addInput(grad)
+  op.execute()
+}
+
+/// Update '*var' according to the adadelta scheme.
+///
+/// accum = rho() * accum + (1 - rho()) * grad.square();
+/// update = (update_accum + epsilon).sqrt() * (accum + epsilon()).rsqrt() * grad;
+/// update_accum = rho() * update_accum + (1 - rho()) * update.square();
+/// var -= update;
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - accum_update: Should be from a Variable().
+///   - lr: Scaling factor. Must be a scalar.
+///   - rho: Decay factor. Must be a scalar.
+///   - epsilon: Constant factor. Must be a scalar.
+///   - grad: The gradient.
+///
+/// - Attr use_locking: If True, updating of the var, accum and update_accum tensors will be protected by
+///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceApplyAdadelta<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  accumUpdate: ResourceHandle,
+  lr: Tensor<T>,
+  rho: Tensor<T>,
+  epsilon: Tensor<T>,
+  grad: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyAdadelta")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(accumUpdate)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(rho)
+  let _ = op.addInput(epsilon)
+  let _ = op.addInput(grad)
+  op.execute()
+}
+
+/// Update '*var' according to the adagrad scheme.
+///
+/// accum += grad * grad
+/// var -= lr * grad * (1 / sqrt(accum))
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - lr: Scaling factor. Must be a scalar.
+///   - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
+///   by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceApplyAdagrad<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  lr: Tensor<T>,
+  grad: Tensor<T>,
+  useLocking: Bool = false,
+  updateSlots: Bool = true
+) {
+  let op = TFE_Op("ResourceApplyAdagrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  op.setAttr("update_slots", updateSlots)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(grad)
+  op.execute()
+}
+
+/// Update '*var' according to the proximal adagrad scheme.
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - gradient_accumulator: Should be from a Variable().
+///   - gradient_squared_accumulator: Should be from a Variable().
+///   - grad: The gradient.
+///   - lr: Scaling factor. Must be a scalar.
+///   - l1: L1 regularization. Must be a scalar.
+///   - l2: L2 regularization. Must be a scalar.
+///   - global_step: Training step number. Must be a scalar.
+///
+/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
+///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceApplyAdagradDA<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  gradientAccumulator: ResourceHandle,
+  gradientSquaredAccumulator: ResourceHandle,
+  grad: Tensor<T>,
+  lr: Tensor<T>,
+  l1: Tensor<T>,
+  l2: Tensor<T>,
+  globalStep: Tensor<Int64>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyAdagradDA")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(gradientAccumulator)
+  let _ = op.addInput(gradientSquaredAccumulator)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  let _ = op.addInput(globalStep)
+  op.execute()
+}
+
+/// Update '*var' according to the Adam algorithm.
+///
+/// $$lr_t := \text{learning\_rate} * \sqrt{1 - beta_2^t} / (1 - beta_1^t)$$
+/// $$m_t := beta_1 * m_{t-1} + (1 - beta_1) * g$$
+/// $$v_t := beta_2 * v_{t-1} + (1 - beta_2) * g * g$$
+/// $$variable := variable - lr_t * m_t / (\sqrt{v_t} + \epsilon)$$
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - m: Should be from a Variable().
+///   - v: Should be from a Variable().
+///   - beta1_power: Must be a scalar.
+///   - beta2_power: Must be a scalar.
+///   - lr: Scaling factor. Must be a scalar.
+///   - beta1: Momentum factor. Must be a scalar.
+///   - beta2: Momentum factor. Must be a scalar.
+///   - epsilon: Ridge term. Must be a scalar.
+///   - grad: The gradient.
+///
+/// - Attrs:
+///   - use_locking: If `True`, updating of the var, m, and v tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+///   - use_nesterov: If `True`, uses the nesterov update.
+@inlinable @inline(__always)
+public static func resourceApplyAdam<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  m: ResourceHandle,
+  v: ResourceHandle,
+  beta1Power: Tensor<T>,
+  beta2Power: Tensor<T>,
+  lr: Tensor<T>,
+  beta1: Tensor<T>,
+  beta2: Tensor<T>,
+  epsilon: Tensor<T>,
+  grad: Tensor<T>,
+  useLocking: Bool = false,
+  useNesterov: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyAdam")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  op.setAttr("use_nesterov", useNesterov)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(m)
+  let _ = op.addInput(v)
+  let _ = op.addInput(beta1Power)
+  let _ = op.addInput(beta2Power)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(beta1)
+  let _ = op.addInput(beta2)
+  let _ = op.addInput(epsilon)
+  let _ = op.addInput(grad)
+  op.execute()
+}
+
+/// Update '*var' according to the Adam algorithm.
+///
+/// $$lr_t := \text{learning\_rate} * \sqrt{1 - beta_2^t} / (1 - beta_1^t)$$
+/// $$m_t := beta_1 * m_{t-1} + (1 - beta_1) * g$$
+/// $$v_t := beta_2 * v_{t-1} + (1 - beta_2) * g * g$$
+/// $$vhat_t := max{vhat_{t-1}, v_t}$$
+/// $$variable := variable - lr_t * m_t / (\sqrt{vhat_t} + \epsilon)$$
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - m: Should be from a Variable().
+///   - v: Should be from a Variable().
+///   - vhat: Should be from a Variable().
+///   - beta1_power: Must be a scalar.
+///   - beta2_power: Must be a scalar.
+///   - lr: Scaling factor. Must be a scalar.
+///   - beta1: Momentum factor. Must be a scalar.
+///   - beta2: Momentum factor. Must be a scalar.
+///   - epsilon: Ridge term. Must be a scalar.
+///   - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var, m, and v tensors will be protected
+///   by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceApplyAdamWithAmsgrad<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  m: ResourceHandle,
+  v: ResourceHandle,
+  vhat: ResourceHandle,
+  beta1Power: Tensor<T>,
+  beta2Power: Tensor<T>,
+  lr: Tensor<T>,
+  beta1: Tensor<T>,
+  beta2: Tensor<T>,
+  epsilon: Tensor<T>,
+  grad: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyAdamWithAmsgrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(m)
+  let _ = op.addInput(v)
+  let _ = op.addInput(vhat)
+  let _ = op.addInput(beta1Power)
+  let _ = op.addInput(beta2Power)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(beta1)
+  let _ = op.addInput(beta2)
+  let _ = op.addInput(epsilon)
+  let _ = op.addInput(grad)
+  op.execute()
+}
+
+/// Update '*var' according to the AddSign update.
+///
+/// m_t <- beta1 * m_{t-1} + (1 - beta1) * g
+/// update <- (alpha + sign_decay * sign(g) *sign(m)) * g
+/// variable <- variable - lr_t * update
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - m: Should be from a Variable().
+///   - lr: Scaling factor. Must be a scalar.
+///   - alpha: Must be a scalar.
+///   - sign_decay: Must be a scalar.
+///   - beta: Must be a scalar.
+///   - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var and m tensors is
+///   protected by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceApplyAddSign<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  m: ResourceHandle,
+  lr: Tensor<T>,
+  alpha: Tensor<T>,
+  signDecay: Tensor<T>,
+  beta: Tensor<T>,
+  grad: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyAddSign")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(m)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(alpha)
+  let _ = op.addInput(signDecay)
+  let _ = op.addInput(beta)
+  let _ = op.addInput(grad)
+  op.execute()
+}
+
+/// Update '*var' according to the centered RMSProp algorithm.
+///
+/// The centered RMSProp algorithm uses an estimate of the centered second moment
+/// (i.e., the variance) for normalization, as opposed to regular RMSProp, which
+/// uses the (uncentered) second moment. This often helps with training, but is
+/// slightly more expensive in terms of computation and memory.
+///
+/// Note that in dense implementation of this algorithm, mg, ms, and mom will
+/// update even if the grad is zero, but in this sparse implementation, mg, ms,
+/// and mom will not update in iterations during which the grad is zero.
+///
+/// mean_square = decay * mean_square + (1-decay) * gradient ** 2
+/// mean_grad = decay * mean_grad + (1-decay) * gradient
+///
+/// Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
+///
+/// mg <- rho * mg_{t-1} + (1-rho) * grad
+/// ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+/// mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms - mg * mg + epsilon)
+/// var <- var - mom
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - mg: Should be from a Variable().
+///   - ms: Should be from a Variable().
+///   - mom: Should be from a Variable().
+///   - lr: Scaling factor. Must be a scalar.
+///   - rho: Decay rate. Must be a scalar.
+///   - epsilon: Ridge term. Must be a scalar.
+///   - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var, mg, ms, and mom tensors is
+///   protected by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceApplyCenteredRMSProp<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  mg: ResourceHandle,
+  ms: ResourceHandle,
+  mom: ResourceHandle,
+  lr: Tensor<T>,
+  rho: Tensor<T>,
+  momentum: Tensor<T>,
+  epsilon: Tensor<T>,
+  grad: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyCenteredRMSProp")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(mg)
+  let _ = op.addInput(ms)
+  let _ = op.addInput(mom)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(rho)
+  let _ = op.addInput(momentum)
+  let _ = op.addInput(epsilon)
+  let _ = op.addInput(grad)
+  op.execute()
+}
+
+/// Update '*var' according to the Ftrl-proximal scheme.
+///
+/// accum_new = accum + grad * grad
+/// linear += grad - (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+/// quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+/// var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+/// accum = accum_new
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - linear: Should be from a Variable().
+///   - grad: The gradient.
+///   - lr: Scaling factor. Must be a scalar.
+///   - l1: L1 regulariation. Must be a scalar.
+///   - l2: L2 regulariation. Must be a scalar.
+///   - lr_power: Scaling factor. Must be a scalar.
+///
+/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
+///   by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceApplyFtrl<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  linear: ResourceHandle,
+  grad: Tensor<T>,
+  lr: Tensor<T>,
+  l1: Tensor<T>,
+  l2: Tensor<T>,
+  lrPower: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyFtrl")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(linear)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  let _ = op.addInput(lrPower)
+  op.execute()
+}
+
+/// Update '*var' according to the Ftrl-proximal scheme.
+///
+/// grad_with_shrinkage = grad + 2 * l2_shrinkage * var
+/// accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
+/// linear += grad_with_shrinkage +
+///     (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+/// quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+/// var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+/// accum = accum_new
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - linear: Should be from a Variable().
+///   - grad: The gradient.
+///   - lr: Scaling factor. Must be a scalar.
+///   - l1: L1 regulariation. Must be a scalar.
+///   - l2: L2 shrinkage regulariation. Must be a scalar.
+///   - lr_power: Scaling factor. Must be a scalar.
+///
+/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
+///   by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceApplyFtrlV2<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  linear: ResourceHandle,
+  grad: Tensor<T>,
+  lr: Tensor<T>,
+  l1: Tensor<T>,
+  l2: Tensor<T>,
+  l2Shrinkage: Tensor<T>,
+  lrPower: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyFtrlV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(linear)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  let _ = op.addInput(l2Shrinkage)
+  let _ = op.addInput(lrPower)
+  op.execute()
+}
+
+/// Update '*var' by subtracting 'alpha' * 'delta' from it.
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - alpha: Scaling factor. Must be a scalar.
+///   - delta: The change.
+///
+/// - Attr use_locking: If `True`, the subtraction will be protected by a lock;
+///   otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceApplyGradientDescent<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  alpha: Tensor<T>,
+  delta: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyGradientDescent")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(alpha)
+  let _ = op.addInput(delta)
+  op.execute()
+}
+
+/// Update '*var' according to the momentum scheme. Set use_nesterov = True if you
+///
+/// want to use Nesterov momentum.
+///
+/// accum = accum * momentum - lr * grad
+/// var += accum
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - lr: Scaling factor. Must be a scalar.
+///   - grad: The gradient.
+///   - momentum: Momentum. Must be a scalar.
+///
+/// - Attrs:
+///   - use_locking: If `True`, updating of the var and accum tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+///   - use_nesterov: If `True`, the tensor passed to compute grad will be
+///     var + momentum * accum, so in the end, the var you get is actually
+///     var + momentum * accum.
+@inlinable @inline(__always)
+public static func resourceApplyKerasMomentum<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  lr: Tensor<T>,
+  grad: Tensor<T>,
+  momentum: Tensor<T>,
+  useLocking: Bool = false,
+  useNesterov: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyKerasMomentum")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  op.setAttr("use_nesterov", useNesterov)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(momentum)
+  op.execute()
+}
+
+/// Update '*var' according to the momentum scheme. Set use_nesterov = True if you
+///
+/// want to use Nesterov momentum.
+///
+/// accum = accum * momentum + grad
+/// var -= lr * accum
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - lr: Scaling factor. Must be a scalar.
+///   - grad: The gradient.
+///   - momentum: Momentum. Must be a scalar.
+///
+/// - Attrs:
+///   - use_locking: If `True`, updating of the var and accum tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+///   - use_nesterov: If `True`, the tensor passed to compute grad will be
+///     var - lr * momentum * accum, so in the end, the var you get is actually
+///     var - lr * momentum * accum.
+@inlinable @inline(__always)
+public static func resourceApplyMomentum<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  lr: Tensor<T>,
+  grad: Tensor<T>,
+  momentum: Tensor<T>,
+  useLocking: Bool = false,
+  useNesterov: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyMomentum")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  op.setAttr("use_nesterov", useNesterov)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(momentum)
+  op.execute()
+}
+
+/// Update '*var' according to the AddSign update.
+///
+/// m_t <- beta1 * m_{t-1} + (1 - beta1) * g
+/// update <- exp(logbase * sign_decay * sign(g) * sign(m_t)) * g
+/// variable <- variable - lr_t * update
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - m: Should be from a Variable().
+///   - lr: Scaling factor. Must be a scalar.
+///   - logbase: Must be a scalar.
+///   - sign_decay: Must be a scalar.
+///   - beta: Must be a scalar.
+///   - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var and m tensors is
+///   protected by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceApplyPowerSign<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  m: ResourceHandle,
+  lr: Tensor<T>,
+  logbase: Tensor<T>,
+  signDecay: Tensor<T>,
+  beta: Tensor<T>,
+  grad: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyPowerSign")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(m)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(logbase)
+  let _ = op.addInput(signDecay)
+  let _ = op.addInput(beta)
+  let _ = op.addInput(grad)
+  op.execute()
+}
+
+/// Update '*var' and '*accum' according to FOBOS with Adagrad learning rate.
+///
+/// accum += grad * grad
+/// prox_v = var - lr * grad * (1 / sqrt(accum))
+/// var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - lr: Scaling factor. Must be a scalar.
+///   - l1: L1 regularization. Must be a scalar.
+///   - l2: L2 regularization. Must be a scalar.
+///   - grad: The gradient.
+///
+/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
+///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceApplyProximalAdagrad<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  lr: Tensor<T>,
+  l1: Tensor<T>,
+  l2: Tensor<T>,
+  grad: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyProximalAdagrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  let _ = op.addInput(grad)
+  op.execute()
+}
+
+/// Update '*var' as FOBOS algorithm with fixed learning rate.
+///
+/// prox_v = var - alpha * delta
+/// var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - alpha: Scaling factor. Must be a scalar.
+///   - l1: L1 regularization. Must be a scalar.
+///   - l2: L2 regularization. Must be a scalar.
+///   - delta: The change.
+///
+/// - Attr use_locking: If True, the subtraction will be protected by a lock;
+///   otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceApplyProximalGradientDescent<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  alpha: Tensor<T>,
+  l1: Tensor<T>,
+  l2: Tensor<T>,
+  delta: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyProximalGradientDescent")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(alpha)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  let _ = op.addInput(delta)
+  op.execute()
+}
+
+/// Update '*var' according to the RMSProp algorithm.
+///
+/// Note that in dense implementation of this algorithm, ms and mom will
+/// update even if the grad is zero, but in this sparse implementation, ms
+/// and mom will not update in iterations during which the grad is zero.
+///
+/// mean_square = decay * mean_square + (1-decay) * gradient ** 2
+/// Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
+///
+/// ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+/// mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
+/// var <- var - mom
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - ms: Should be from a Variable().
+///   - mom: Should be from a Variable().
+///   - lr: Scaling factor. Must be a scalar.
+///   - rho: Decay rate. Must be a scalar.
+///   - epsilon: Ridge term. Must be a scalar.
+///   - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var, ms, and mom tensors is protected
+///   by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceApplyRMSProp<T: Numeric & TensorFlowScalar>(
+  var_: ResourceHandle,
+  ms: ResourceHandle,
+  mom: ResourceHandle,
+  lr: Tensor<T>,
+  rho: Tensor<T>,
+  momentum: Tensor<T>,
+  epsilon: Tensor<T>,
+  grad: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceApplyRMSProp")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(ms)
+  let _ = op.addInput(mom)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(rho)
+  let _ = op.addInput(momentum)
+  let _ = op.addInput(epsilon)
+  let _ = op.addInput(grad)
+  op.execute()
+}
+
+/// Increments variable pointed to by 'resource' until it reaches 'limit'.
+///
+/// - Parameter resource: Should be from a scalar `Variable` node.
+///
+/// - Attr limit: If incrementing ref would bring it above limit, instead generates an
+///   'OutOfRange' error.
+///
+/// - Output output: A copy of the input before increment. If nothing else modifies the
+///   input, the values produced will all be distinct.
+@inlinable @inline(__always)
+public static func resourceCountUpTo<T: BinaryInteger & TensorFlowScalar>(
+  resource: ResourceHandle,
+  limit: Int64
+) -> Tensor<T> {
+  let op = TFE_Op("ResourceCountUpTo")
+  op.setAttr("limit", limit)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func resourceCreateOp(
+  resource: ResourceHandle
+) {
+  let op = TFE_Op("ResourceCreateOp")
+  let _ = op.addInput(resource)
+  op.execute()
+}
+
+/// Gather slices from the variable pointed to by `resource` according to `indices`.
+///
+/// `indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
+/// Produces an output tensor with shape `indices.shape + params.shape[1:]` where:
+///
+/// ```python
+///     # Scalar indices
+///     output[:, ..., :] = params[indices, :, ... :]
+///
+///     # Vector indices
+///     output[i, :, ..., :] = params[indices[i], :, ... :]
+///
+///     # Higher rank indices
+///     output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
+/// ```
+@inlinable @inline(__always)
+public static func resourceGather<
+    Dtype: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  indices: Tensor<Tindices>,
+  batchDims: Int64 = 0,
+  validateIndices: Bool = true
+) -> Tensor<Dtype> {
+  let op = TFE_Op("ResourceGather")
+  op.setAttr("batch_dims", batchDims)
+  op.setAttr("validate_indices", validateIndices)
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(indices)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func resourceGatherNd<
+    Dtype: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  indices: Tensor<Tindices>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("ResourceGatherNd")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(indices)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func resourceInitializedOp(
+  resource: ResourceHandle
+) -> Tensor<Bool> {
+  let op = TFE_Op("ResourceInitializedOp")
+  let _ = op.addInput(resource)
+  return op.execute(Int(1))
+}
+
+/// Adds sparse updates to the variable referenced by `resource`.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] += updates[...]
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] += updates[i, ...]
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions add.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+/// </div>
+///
+/// - Parameters:
+///   - resource: Should be from a `Variable` node.
+///   - indices: A tensor of indices into the first dimension of `ref`.
+///   - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterAdd<
+    Dtype: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  indices: Tensor<Tindices>,
+  updates: Tensor<Dtype>
+) {
+  let op = TFE_Op("ResourceScatterAdd")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  op.execute()
+}
+
+/// Divides sparse updates into the variable referenced by `resource`.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] /= updates[...]
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] /= updates[i, ...]
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] /= updates[i, ..., j, ...]
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions multiply.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+/// </div>
+///
+/// - Parameters:
+///   - resource: Should be from a `Variable` node.
+///   - indices: A tensor of indices into the first dimension of `ref`.
+///   - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterDiv<
+    Dtype: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  indices: Tensor<Tindices>,
+  updates: Tensor<Dtype>
+) {
+  let op = TFE_Op("ResourceScatterDiv")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  op.execute()
+}
+
+/// Reduces sparse updates into the variable referenced by `resource` using the `max` operation.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] = max(ref[indices, ...], updates[...])
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] = max(ref[indices[i], ...], updates[i, ...])
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] = max(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions are combined.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+/// </div>
+///
+/// - Parameters:
+///   - resource: Should be from a `Variable` node.
+///   - indices: A tensor of indices into the first dimension of `ref`.
+///   - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterMax<
+    Dtype: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  indices: Tensor<Tindices>,
+  updates: Tensor<Dtype>
+) {
+  let op = TFE_Op("ResourceScatterMax")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  op.execute()
+}
+
+/// Reduces sparse updates into the variable referenced by `resource` using the `min` operation.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] = min(ref[indices, ...], updates[...])
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] = min(ref[indices[i], ...], updates[i, ...])
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] = min(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions are combined.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+/// </div>
+///
+/// - Parameters:
+///   - resource: Should be from a `Variable` node.
+///   - indices: A tensor of indices into the first dimension of `ref`.
+///   - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterMin<
+    Dtype: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  indices: Tensor<Tindices>,
+  updates: Tensor<Dtype>
+) {
+  let op = TFE_Op("ResourceScatterMin")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  op.execute()
+}
+
+/// Multiplies sparse updates into the variable referenced by `resource`.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] *= updates[...]
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] *= updates[i, ...]
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] *= updates[i, ..., j, ...]
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions multiply.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+/// </div>
+///
+/// - Parameters:
+///   - resource: Should be from a `Variable` node.
+///   - indices: A tensor of indices into the first dimension of `ref`.
+///   - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterMul<
+    Dtype: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  indices: Tensor<Tindices>,
+  updates: Tensor<Dtype>
+) {
+  let op = TFE_Op("ResourceScatterMul")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  op.execute()
+}
+
+/// Applies sparse addition to individual values or slices in a Variable.
+///
+/// `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+///
+/// `indices` must be integer tensor, containing indices into `ref`.
+/// It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+///
+/// The innermost dimension of `indices` (with length `K`) corresponds to
+/// indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
+/// dimension of `ref`.
+///
+/// `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+///
+/// ```
+/// [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
+/// ```
+///
+/// For example, say we want to add 4 scattered elements to a rank-1 tensor to
+/// 8 elements. In Python, that addition would look like this:
+///
+/// ```python
+/// ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8], use_resource=True)
+/// indices = tf.constant([[4], [3], [1], [7]])
+/// updates = tf.constant([9, 10, 11, 12])
+/// add = tf.scatter_nd_add(ref, indices, updates)
+/// with tf.Session() as sess:
+///   print sess.run(add)
+/// ```
+///
+/// The resulting update to ref would look like this:
+///
+///     [1, 13, 3, 14, 14, 6, 7, 20]
+///
+/// See `tf.scatter_nd` for more details about how to make updates to
+/// slices.
+///
+/// - Parameters:
+///   - ref: A resource handle. Must be from a VarHandleOp.
+///   - indices: A Tensor. Must be one of the following types: int32, int64.
+///     A tensor of indices into ref.
+///   - updates: A Tensor. Must have the same type as ref. A tensor of
+///     values to add to ref.
+///
+/// - Attr use_locking: An optional bool. Defaults to True. If True, the assignment will
+///   be protected by a lock; otherwise the behavior is undefined,
+///   but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceScatterNdAdd<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  ref: ResourceHandle,
+  indices: Tensor<Tindices>,
+  updates: Tensor<T>,
+  useLocking: Bool = true
+) {
+  let op = TFE_Op("ResourceScatterNdAdd")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(ref)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  op.execute()
+}
+
+/// Applies sparse subtraction to individual values or slices in a Variable.
+///
+/// `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+///
+/// `indices` must be integer tensor, containing indices into `ref`.
+/// It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+///
+/// The innermost dimension of `indices` (with length `K`) corresponds to
+/// indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
+/// dimension of `ref`.
+///
+/// `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+///
+/// ```
+/// [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
+/// ```
+///
+/// For example, say we want to subtract 4 scattered elements from a rank-1 tensor
+/// with 8 elements. In Python, that subtraction would look like this:
+///
+/// ```python
+/// ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8], use_resource=True)
+/// indices = tf.constant([[4], [3], [1], [7]])
+/// updates = tf.constant([9, 10, 11, 12])
+/// sub = tf.scatter_nd_sub(ref, indices, updates)
+/// with tf.Session() as sess:
+///   print sess.run(sub)
+/// ```
+///
+/// The resulting update to ref would look like this:
+///
+///     [1, -9, 3, -6, -4, 6, 7, -4]
+///
+/// See `tf.scatter_nd` for more details about how to make updates to
+/// slices.
+///
+/// - Parameters:
+///   - ref: A resource handle. Must be from a VarHandleOp.
+///   - indices: A Tensor. Must be one of the following types: int32, int64.
+///     A tensor of indices into ref.
+///   - updates: A Tensor. Must have the same type as ref. A tensor of
+///     values to add to ref.
+///
+/// - Attr use_locking: An optional bool. Defaults to True. If True, the assignment will
+///   be protected by a lock; otherwise the behavior is undefined,
+///   but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceScatterNdSub<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  ref: ResourceHandle,
+  indices: Tensor<Tindices>,
+  updates: Tensor<T>,
+  useLocking: Bool = true
+) {
+  let op = TFE_Op("ResourceScatterNdSub")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(ref)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  op.execute()
+}
+
+/// Applies sparse `updates` to individual values or slices within a given
+///
+/// variable according to `indices`.
+///
+/// `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+///
+/// `indices` must be integer tensor, containing indices into `ref`.
+/// It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+///
+/// The innermost dimension of `indices` (with length `K`) corresponds to
+/// indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
+/// dimension of `ref`.
+///
+/// `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+///
+/// ```
+/// [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
+/// ```
+///
+/// For example, say we want to update 4 scattered elements to a rank-1 tensor to
+/// 8 elements. In Python, that update would look like this:
+///
+/// ```python
+///     ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
+///     indices = tf.constant([[4], [3], [1] ,[7]])
+///     updates = tf.constant([9, 10, 11, 12])
+///     update = tf.scatter_nd_update(ref, indices, updates)
+///     with tf.Session() as sess:
+///       print sess.run(update)
+/// ```
+///
+/// The resulting update to ref would look like this:
+///
+///     [1, 11, 3, 10, 9, 6, 7, 12]
+///
+/// See `tf.scatter_nd` for more details about how to make updates to
+/// slices.
+///
+/// - Parameters:
+///   - ref: A resource handle. Must be from a VarHandleOp.
+///   - indices: A Tensor. Must be one of the following types: int32, int64.
+///     A tensor of indices into ref.
+///   - updates: A Tensor. Must have the same type as ref. A tensor of updated
+///     values to add to ref.
+///
+/// - Attr use_locking: An optional bool. Defaults to True. If True, the assignment will
+///   be protected by a lock; otherwise the behavior is undefined,
+///   but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceScatterNdUpdate<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  ref: ResourceHandle,
+  indices: Tensor<Tindices>,
+  updates: Tensor<T>,
+  useLocking: Bool = true
+) {
+  let op = TFE_Op("ResourceScatterNdUpdate")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(ref)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  op.execute()
+}
+
+/// Subtracts sparse updates from the variable referenced by `resource`.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] -= updates[...]
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] -= updates[i, ...]
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] -= updates[i, ..., j, ...]
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions add.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+/// </div>
+///
+/// - Parameters:
+///   - resource: Should be from a `Variable` node.
+///   - indices: A tensor of indices into the first dimension of `ref`.
+///   - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterSub<
+    Dtype: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  indices: Tensor<Tindices>,
+  updates: Tensor<Dtype>
+) {
+  let op = TFE_Op("ResourceScatterSub")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  op.execute()
+}
+
+/// Assigns sparse updates to the variable referenced by `resource`.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] = updates[...]
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] = updates[i, ...]
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]
+///
+/// - Parameters:
+///   - resource: Should be from a `Variable` node.
+///   - indices: A tensor of indices into the first dimension of `ref`.
+///   - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterUpdate<
+    Dtype: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  indices: Tensor<Tindices>,
+  updates: Tensor<Dtype>
+) {
+  let op = TFE_Op("ResourceScatterUpdate")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  op.execute()
+}
+
+/// var: Should be from a Variable().
+///
+/// - Parameters:
+///   - accum: Should be from a Variable().
+///   - accum_update: : Should be from a Variable().
+///   - lr: Learning rate. Must be a scalar.
+///   - rho: Decay factor. Must be a scalar.
+///   - epsilon: Constant factor. Must be a scalar.
+///   - grad: The gradient.
+///   - indices: A vector of indices into the first dimension of var and accum.
+///
+/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
+///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyAdadelta<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  accumUpdate: ResourceHandle,
+  lr: Tensor<T>,
+  rho: Tensor<T>,
+  epsilon: Tensor<T>,
+  grad: Tensor<T>,
+  indices: Tensor<Tindices>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceSparseApplyAdadelta")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(accumUpdate)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(rho)
+  let _ = op.addInput(epsilon)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  op.execute()
+}
+
+/// Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
+///
+/// That is for rows we have grad for, we update var and accum as follows:
+/// accum += grad * grad
+/// var -= lr * grad * (1 / sqrt(accum))
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - lr: Learning rate. Must be a scalar.
+///   - grad: The gradient.
+///   - indices: A vector of indices into the first dimension of var and accum.
+///
+/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
+///   by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyAdagrad<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  lr: Tensor<T>,
+  grad: Tensor<T>,
+  indices: Tensor<Tindices>,
+  useLocking: Bool = false,
+  updateSlots: Bool = true
+) {
+  let op = TFE_Op("ResourceSparseApplyAdagrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  op.setAttr("update_slots", updateSlots)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  op.execute()
+}
+
+/// Update entries in '*var' and '*accum' according to the proximal adagrad scheme.
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - gradient_accumulator: Should be from a Variable().
+///   - gradient_squared_accumulator: Should be from a Variable().
+///   - grad: The gradient.
+///   - indices: A vector of indices into the first dimension of var and accum.
+///   - lr: Learning rate. Must be a scalar.
+///   - l1: L1 regularization. Must be a scalar.
+///   - l2: L2 regularization. Must be a scalar.
+///   - global_step: Training step number. Must be a scalar.
+///
+/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
+///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyAdagradDA<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  var_: ResourceHandle,
+  gradientAccumulator: ResourceHandle,
+  gradientSquaredAccumulator: ResourceHandle,
+  grad: Tensor<T>,
+  indices: Tensor<Tindices>,
+  lr: Tensor<T>,
+  l1: Tensor<T>,
+  l2: Tensor<T>,
+  globalStep: Tensor<Int64>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceSparseApplyAdagradDA")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(gradientAccumulator)
+  let _ = op.addInput(gradientSquaredAccumulator)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  let _ = op.addInput(globalStep)
+  op.execute()
+}
+
+/// Update '*var' according to the centered RMSProp algorithm.
+///
+/// The centered RMSProp algorithm uses an estimate of the centered second moment
+/// (i.e., the variance) for normalization, as opposed to regular RMSProp, which
+/// uses the (uncentered) second moment. This often helps with training, but is
+/// slightly more expensive in terms of computation and memory.
+///
+/// Note that in dense implementation of this algorithm, mg, ms, and mom will
+/// update even if the grad is zero, but in this sparse implementation, mg, ms,
+/// and mom will not update in iterations during which the grad is zero.
+///
+/// mean_square = decay * mean_square + (1-decay) * gradient ** 2
+/// mean_grad = decay * mean_grad + (1-decay) * gradient
+/// Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
+///
+/// ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+/// mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
+/// var <- var - mom
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - mg: Should be from a Variable().
+///   - ms: Should be from a Variable().
+///   - mom: Should be from a Variable().
+///   - lr: Scaling factor. Must be a scalar.
+///   - rho: Decay rate. Must be a scalar.
+///   - epsilon: Ridge term. Must be a scalar.
+///   - grad: The gradient.
+///   - indices: A vector of indices into the first dimension of var, ms and mom.
+///
+/// - Attr use_locking: If `True`, updating of the var, mg, ms, and mom tensors is
+///   protected by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyCenteredRMSProp<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  var_: ResourceHandle,
+  mg: ResourceHandle,
+  ms: ResourceHandle,
+  mom: ResourceHandle,
+  lr: Tensor<T>,
+  rho: Tensor<T>,
+  momentum: Tensor<T>,
+  epsilon: Tensor<T>,
+  grad: Tensor<T>,
+  indices: Tensor<Tindices>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceSparseApplyCenteredRMSProp")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(mg)
+  let _ = op.addInput(ms)
+  let _ = op.addInput(mom)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(rho)
+  let _ = op.addInput(momentum)
+  let _ = op.addInput(epsilon)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  op.execute()
+}
+
+/// Update relevant entries in '*var' according to the Ftrl-proximal scheme.
+///
+/// That is for rows we have grad for, we update var, accum and linear as follows:
+/// accum_new = accum + grad * grad
+/// linear += grad + (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+/// quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+/// var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+/// accum = accum_new
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - linear: Should be from a Variable().
+///   - grad: The gradient.
+///   - indices: A vector of indices into the first dimension of var and accum.
+///   - lr: Scaling factor. Must be a scalar.
+///   - l1: L1 regularization. Must be a scalar.
+///   - l2: L2 regularization. Must be a scalar.
+///   - lr_power: Scaling factor. Must be a scalar.
+///
+/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
+///   by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyFtrl<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  linear: ResourceHandle,
+  grad: Tensor<T>,
+  indices: Tensor<Tindices>,
+  lr: Tensor<T>,
+  l1: Tensor<T>,
+  l2: Tensor<T>,
+  lrPower: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceSparseApplyFtrl")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(linear)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  let _ = op.addInput(lrPower)
+  op.execute()
+}
+
+/// Update relevant entries in '*var' according to the Ftrl-proximal scheme.
+///
+/// That is for rows we have grad for, we update var, accum and linear as follows:
+/// grad_with_shrinkage = grad + 2 * l2_shrinkage * var
+/// accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
+/// linear += grad_with_shrinkage +
+///     (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+/// quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+/// var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+/// accum = accum_new
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - linear: Should be from a Variable().
+///   - grad: The gradient.
+///   - indices: A vector of indices into the first dimension of var and accum.
+///   - lr: Scaling factor. Must be a scalar.
+///   - l1: L1 regularization. Must be a scalar.
+///   - l2: L2 shrinkage regulariation. Must be a scalar.
+///   - lr_power: Scaling factor. Must be a scalar.
+///
+/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
+///   by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyFtrlV2<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  linear: ResourceHandle,
+  grad: Tensor<T>,
+  indices: Tensor<Tindices>,
+  lr: Tensor<T>,
+  l1: Tensor<T>,
+  l2: Tensor<T>,
+  l2Shrinkage: Tensor<T>,
+  lrPower: Tensor<T>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceSparseApplyFtrlV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(linear)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  let _ = op.addInput(l2Shrinkage)
+  let _ = op.addInput(lrPower)
+  op.execute()
+}
+
+/// Update relevant entries in '*var' and '*accum' according to the momentum scheme.
+///
+/// Set use_nesterov = True if you want to use Nesterov momentum.
+///
+/// That is for rows we have grad for, we update var and accum as follows:
+///
+/// accum = accum * momentum - lr * grad
+/// var += accum
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - lr: Learning rate. Must be a scalar.
+///   - grad: The gradient.
+///   - indices: A vector of indices into the first dimension of var and accum.
+///   - momentum: Momentum. Must be a scalar.
+///
+/// - Attrs:
+///   - use_locking: If `True`, updating of the var and accum tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+///   - use_nesterov: If `True`, the tensor passed to compute grad will be
+///     var + momentum * accum, so in the end, the var you get is actually
+///     var + momentum * accum.
+@inlinable @inline(__always)
+public static func resourceSparseApplyKerasMomentum<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  lr: Tensor<T>,
+  grad: Tensor<T>,
+  indices: Tensor<Tindices>,
+  momentum: Tensor<T>,
+  useLocking: Bool = false,
+  useNesterov: Bool = false
+) {
+  let op = TFE_Op("ResourceSparseApplyKerasMomentum")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  op.setAttr("use_nesterov", useNesterov)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(momentum)
+  op.execute()
+}
+
+/// Update relevant entries in '*var' and '*accum' according to the momentum scheme.
+///
+/// Set use_nesterov = True if you want to use Nesterov momentum.
+///
+/// That is for rows we have grad for, we update var and accum as follows:
+///
+/// accum = accum * momentum + grad
+/// var -= lr * accum
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - lr: Learning rate. Must be a scalar.
+///   - grad: The gradient.
+///   - indices: A vector of indices into the first dimension of var and accum.
+///   - momentum: Momentum. Must be a scalar.
+///
+/// - Attrs:
+///   - use_locking: If `True`, updating of the var and accum tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+///   - use_nesterov: If `True`, the tensor passed to compute grad will be
+///     var - lr * momentum * accum, so in the end, the var you get is actually
+///     var - lr * momentum * accum.
+@inlinable @inline(__always)
+public static func resourceSparseApplyMomentum<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  lr: Tensor<T>,
+  grad: Tensor<T>,
+  indices: Tensor<Tindices>,
+  momentum: Tensor<T>,
+  useLocking: Bool = false,
+  useNesterov: Bool = false
+) {
+  let op = TFE_Op("ResourceSparseApplyMomentum")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  op.setAttr("use_nesterov", useNesterov)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(momentum)
+  op.execute()
+}
+
+/// Sparse update entries in '*var' and '*accum' according to FOBOS algorithm.
+///
+/// That is for rows we have grad for, we update var and accum as follows:
+/// accum += grad * grad
+/// prox_v = var
+/// prox_v -= lr * grad * (1 / sqrt(accum))
+/// var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - accum: Should be from a Variable().
+///   - lr: Learning rate. Must be a scalar.
+///   - l1: L1 regularization. Must be a scalar.
+///   - l2: L2 regularization. Must be a scalar.
+///   - grad: The gradient.
+///   - indices: A vector of indices into the first dimension of var and accum.
+///
+/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
+///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyProximalAdagrad<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  var_: ResourceHandle,
+  accum: ResourceHandle,
+  lr: Tensor<T>,
+  l1: Tensor<T>,
+  l2: Tensor<T>,
+  grad: Tensor<T>,
+  indices: Tensor<Tindices>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceSparseApplyProximalAdagrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(accum)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  op.execute()
+}
+
+/// Sparse update '*var' as FOBOS algorithm with fixed learning rate.
+///
+/// That is for rows we have grad for, we update var as follows:
+/// prox_v = var - alpha * grad
+/// var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - alpha: Scaling factor. Must be a scalar.
+///   - l1: L1 regularization. Must be a scalar.
+///   - l2: L2 regularization. Must be a scalar.
+///   - grad: The gradient.
+///   - indices: A vector of indices into the first dimension of var and accum.
+///
+/// - Attr use_locking: If True, the subtraction will be protected by a lock;
+///   otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyProximalGradientDescent<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  var_: ResourceHandle,
+  alpha: Tensor<T>,
+  l1: Tensor<T>,
+  l2: Tensor<T>,
+  grad: Tensor<T>,
+  indices: Tensor<Tindices>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceSparseApplyProximalGradientDescent")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(alpha)
+  let _ = op.addInput(l1)
+  let _ = op.addInput(l2)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  op.execute()
+}
+
+/// Update '*var' according to the RMSProp algorithm.
+///
+/// Note that in dense implementation of this algorithm, ms and mom will
+/// update even if the grad is zero, but in this sparse implementation, ms
+/// and mom will not update in iterations during which the grad is zero.
+///
+/// mean_square = decay * mean_square + (1-decay) * gradient ** 2
+/// Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
+///
+/// ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+/// mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
+/// var <- var - mom
+///
+/// - Parameters:
+///   - var: Should be from a Variable().
+///   - ms: Should be from a Variable().
+///   - mom: Should be from a Variable().
+///   - lr: Scaling factor. Must be a scalar.
+///   - rho: Decay rate. Must be a scalar.
+///   - epsilon: Ridge term. Must be a scalar.
+///   - grad: The gradient.
+///   - indices: A vector of indices into the first dimension of var, ms and mom.
+///
+/// - Attr use_locking: If `True`, updating of the var, ms, and mom tensors is protected
+///   by a lock; otherwise the behavior is undefined, but may exhibit less
+///   contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyRMSProp<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  var_: ResourceHandle,
+  ms: ResourceHandle,
+  mom: ResourceHandle,
+  lr: Tensor<T>,
+  rho: Tensor<T>,
+  momentum: Tensor<T>,
+  epsilon: Tensor<T>,
+  grad: Tensor<T>,
+  indices: Tensor<Tindices>,
+  useLocking: Bool = false
+) {
+  let op = TFE_Op("ResourceSparseApplyRMSProp")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("use_locking", useLocking)
+  let _ = op.addInput(var_)
+  let _ = op.addInput(ms)
+  let _ = op.addInput(mom)
+  let _ = op.addInput(lr)
+  let _ = op.addInput(rho)
+  let _ = op.addInput(momentum)
+  let _ = op.addInput(epsilon)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  op.execute()
+}
+
+/// Assign `value` to the sliced l-value reference of `ref`.
+///
+/// The values of `value` are assigned to the positions in the variable
+/// `ref` that are selected by the slice parameters. The slice parameters
+/// `begin, `end`, `strides`, etc. work exactly as in `StridedSlice`.
+///
+/// NOTE this op currently does not support broadcasting and so `value`'s
+/// shape must be exactly the shape produced by the slice of `ref`.
+@inlinable @inline(__always)
+public static func resourceStridedSliceAssign<
+    T: TensorFlowScalar,
+    Index: BinaryInteger & TensorFlowScalar
+>(
+  ref: ResourceHandle,
+  begin: Tensor<Index>,
+  end: Tensor<Index>,
+  strides: Tensor<Index>,
+  value: Tensor<T>,
+  beginMask: Int64 = 0,
+  endMask: Int64 = 0,
+  ellipsisMask: Int64 = 0,
+  newAxisMask: Int64 = 0,
+  shrinkAxisMask: Int64 = 0
+) {
+  let op = TFE_Op("ResourceStridedSliceAssign")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Index", Index.tensorFlowDataType)
+  op.setAttr("begin_mask", beginMask)
+  op.setAttr("end_mask", endMask)
+  op.setAttr("ellipsis_mask", ellipsisMask)
+  op.setAttr("new_axis_mask", newAxisMask)
+  op.setAttr("shrink_axis_mask", shrinkAxisMask)
+  let _ = op.addInput(ref)
+  let _ = op.addInput(begin)
+  let _ = op.addInput(end)
+  let _ = op.addInput(strides)
+  let _ = op.addInput(value)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func resourceUsingOp(
+  resource: ResourceHandle
+) {
+  let op = TFE_Op("ResourceUsingOp")
+  let _ = op.addInput(resource)
+  op.execute()
+}
+
+/// Restores a tensor from checkpoint files.
+///
+/// Reads a tensor stored in one or several files. If there are several files (for
+/// instance because a tensor was saved as slices), `file_pattern` may contain
+/// wildcard symbols (`*` and `?`) in the filename portion only, not in the
+/// directory portion.
+///
+/// If a `file_pattern` matches several files, `preferred_shard` can be used to hint
+/// in which file the requested tensor is likely to be found. This op will first
+/// open the file at index `preferred_shard` in the list of matching files and try
+/// to restore tensors from that file.  Only if some tensors or tensor slices are
+/// not found in that first file, then the Op opens all the files. Setting
+/// `preferred_shard` to match the value passed as the `shard` input
+/// of a matching `Save` Op may speed up Restore.  This attribute only affects
+/// performance, not correctness.  The default value -1 means files are processed in
+/// order.
+///
+/// See also `RestoreSlice`.
+///
+/// - Parameters:
+///   - file_pattern: Must have a single element. The pattern of the files from
+///     which we read the tensor.
+///   - tensor_name: Must have a single element. The name of the tensor to be
+///     restored.
+///
+/// - Attrs:
+///   - dt: The type of the tensor to be restored.
+///   - preferred_shard: Index of file to open first if multiple files match
+///     `file_pattern`.
+///
+/// - Output tensor: The restored tensor.
+@inlinable @inline(__always)
+public static func restore<Dt: TensorFlowScalar>(
+  filePattern: StringTensor,
+  tensorName: StringTensor,
+  preferredShard: Int64 = -1
+) -> Tensor<Dt> {
+  let op = TFE_Op("Restore")
+  op.setAttr("dt", Dt.tensorFlowDataType)
+  op.setAttr("preferred_shard", preferredShard)
+  let _ = op.addInput(filePattern)
+  let _ = op.addInput(tensorName)
+  return op.execute(Int(1))
+}
+
+/// Restores a tensor from checkpoint files.
+///
+/// This is like `Restore` except that restored tensor can be listed as filling
+/// only a slice of a larger tensor.  `shape_and_slice` specifies the shape of the
+/// larger tensor and the slice that the restored tensor covers.
+///
+/// The `shape_and_slice` input has the same format as the
+/// elements of the `shapes_and_slices` input of the `SaveSlices` op.
+///
+/// - Parameters:
+///   - file_pattern: Must have a single element. The pattern of the files from
+///     which we read the tensor.
+///   - tensor_name: Must have a single element. The name of the tensor to be
+///     restored.
+///   - shape_and_slice: Scalar. The shapes and slice specifications to use when
+///     restoring a tensors.
+///
+/// - Attrs:
+///   - dt: The type of the tensor to be restored.
+///   - preferred_shard: Index of file to open first if multiple files match
+///     `file_pattern`. See the documentation for `Restore`.
+///
+/// - Output tensor: The restored tensor.
+@inlinable @inline(__always)
+public static func restoreSlice<Dt: TensorFlowScalar>(
+  filePattern: StringTensor,
+  tensorName: StringTensor,
+  shapeAndSlice: StringTensor,
+  preferredShard: Int64 = -1
+) -> Tensor<Dt> {
+  let op = TFE_Op("RestoreSlice")
+  op.setAttr("dt", Dt.tensorFlowDataType)
+  op.setAttr("preferred_shard", preferredShard)
+  let _ = op.addInput(filePattern)
+  let _ = op.addInput(tensorName)
+  let _ = op.addInput(shapeAndSlice)
+  return op.execute(Int(1))
+}
+
+/// Restores tensors from a V2 checkpoint.
+///
+/// For backward compatibility with the V1 format, this Op currently allows
+/// restoring from a V1 checkpoint as well:
+///   - This Op first attempts to find the V2 index file pointed to by "prefix", and
+///     if found proceed to read it as a V2 checkpoint;
+///   - Otherwise the V1 read path is invoked.
+/// Relying on this behavior is not recommended, as the ability to fall back to read
+/// V1 might be deprecated and eventually removed.
+///
+/// By default, restores the named tensors in full.  If the caller wishes to restore
+/// specific slices of stored tensors, "shape_and_slices" should be non-empty
+/// strings and correspondingly well-formed.
+///
+/// Callers must ensure all the named tensors are indeed stored in the checkpoint.
+///
+/// - Parameters:
+///   - prefix: Must have a single element.  The prefix of a V2 checkpoint.
+///   - tensor_names: shape {N}.  The names of the tensors to be restored.
+///   - shape_and_slices: shape {N}.  The slice specs of the tensors to be restored.
+///     Empty strings indicate that they are non-partitioned tensors.
+///
+/// - Attr dtypes: shape {N}.  The list of expected dtype for the tensors.  Must match
+///   those stored in the checkpoint.
+///
+/// - Output tensors: shape {N}.  The restored tensors, whose shapes are read from the
+///   checkpoint directly.
+@inlinable @inline(__always)
+public static func restoreV2<Dtypes: TensorGroup>(
+  prefix: StringTensor,
+  tensorNames: StringTensor,
+  shapeAndSlices: StringTensor
+) -> Dtypes {
+  let op = TFE_Op("RestoreV2")
+  op.setAttr("dtypes", Dtypes._typeList)
+  let _ = op.addInput(prefix)
+  let _ = op.addInput(tensorNames)
+  let _ = op.addInput(shapeAndSlices)
+  return op.execute(Int(Dtypes._typeList.count))
+}
+
+@inlinable @inline(__always)
+public static func restrict<T: TensorFlowScalar>(
+  _ a: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Restrict")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func restrict(
+  _ a: StringTensor
+) -> StringTensor {
+  let op = TFE_Op("Restrict")
+  op.setAttr("T", TensorDataType(TF_STRING))
+  let _ = op.addInput(a)
+  return op.execute(Int(1))
+}
+
+/// Retrieve ADAM embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the ADAM optimization algorithm.
+///   - momenta: Parameter momenta updated by the ADAM optimization algorithm.
+///   - velocities: Parameter velocities updated by the ADAM optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingADAMParameters(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, momenta: Tensor<Float>, velocities: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingADAMParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve ADAM embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the ADAM optimization algorithm.
+///   - momenta: Parameter momenta updated by the ADAM optimization algorithm.
+///   - velocities: Parameter velocities updated by the ADAM optimization algorithm.
+///   - gradient_accumulators: Parameter gradient_accumulators updated by the ADAM optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingADAMParametersGradAccumDebug(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, momenta: Tensor<Float>, velocities: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingADAMParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Retrieve Adadelta embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the Adadelta optimization algorithm.
+///   - accumulators: Parameter accumulators updated by the Adadelta optimization algorithm.
+///   - updates: Parameter updates updated by the Adadelta optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingAdadeltaParameters(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, updates: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingAdadeltaParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve Adadelta embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the Adadelta optimization algorithm.
+///   - accumulators: Parameter accumulators updated by the Adadelta optimization algorithm.
+///   - updates: Parameter updates updated by the Adadelta optimization algorithm.
+///   - gradient_accumulators: Parameter gradient_accumulators updated by the Adadelta optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingAdadeltaParametersGradAccumDebug(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, updates: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Retrieve Adagrad embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the Adagrad optimization algorithm.
+///   - accumulators: Parameter accumulators updated by the Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingAdagradParameters(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingAdagradParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Retrieve Adagrad embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the Adagrad optimization algorithm.
+///   - accumulators: Parameter accumulators updated by the Adagrad optimization algorithm.
+///   - gradient_accumulators: Parameter gradient_accumulators updated by the Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingAdagradParametersGradAccumDebug(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingAdagradParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve centered RMSProp embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the centered RMSProp optimization algorithm.
+///   - ms: Parameter ms updated by the centered RMSProp optimization algorithm.
+///   - mom: Parameter mom updated by the centered RMSProp optimization algorithm.
+///   - mg: Parameter mg updated by the centered RMSProp optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingCenteredRMSPropParameters(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, ms: Tensor<Float>, mom: Tensor<Float>, mg: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingCenteredRMSPropParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Retrieve FTRL embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the FTRL optimization algorithm.
+///   - accumulators: Parameter accumulators updated by the FTRL optimization algorithm.
+///   - linears: Parameter linears updated by the FTRL optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingFTRLParameters(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, linears: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingFTRLParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve FTRL embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the FTRL optimization algorithm.
+///   - accumulators: Parameter accumulators updated by the FTRL optimization algorithm.
+///   - linears: Parameter linears updated by the FTRL optimization algorithm.
+///   - gradient_accumulators: Parameter gradient_accumulators updated by the FTRL optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingFTRLParametersGradAccumDebug(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, linears: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingFTRLParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Retrieve MDL Adagrad Light embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the MDL Adagrad Light optimization algorithm.
+///   - accumulators: Parameter accumulators updated by the MDL Adagrad Light optimization algorithm.
+///   - weights: Parameter weights updated by the MDL Adagrad Light optimization algorithm.
+///   - benefits: Parameter benefits updated by the MDL Adagrad Light optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingMDLAdagradLightParameters(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, weights: Tensor<Float>, benefits: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingMDLAdagradLightParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Retrieve Momentum embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the Momentum optimization algorithm.
+///   - momenta: Parameter momenta updated by the Momentum optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingMomentumParameters(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, momenta: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingMomentumParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Retrieve Momentum embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the Momentum optimization algorithm.
+///   - momenta: Parameter momenta updated by the Momentum optimization algorithm.
+///   - gradient_accumulators: Parameter gradient_accumulators updated by the Momentum optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingMomentumParametersGradAccumDebug(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, momenta: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingMomentumParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve proximal Adagrad embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the proximal Adagrad optimization algorithm.
+///   - accumulators: Parameter accumulators updated by the proximal Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingProximalAdagradParameters(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingProximalAdagradParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Retrieve proximal Adagrad embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the proximal Adagrad optimization algorithm.
+///   - accumulators: Parameter accumulators updated by the proximal Adagrad optimization algorithm.
+///   - gradient_accumulators: Parameter gradient_accumulators updated by the proximal Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve RMSProp embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the RMSProp optimization algorithm.
+///   - ms: Parameter ms updated by the RMSProp optimization algorithm.
+///   - mom: Parameter mom updated by the RMSProp optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingRMSPropParameters(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, ms: Tensor<Float>, mom: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingRMSPropParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve RMSProp embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///   - parameters: Parameter parameters updated by the RMSProp optimization algorithm.
+///   - ms: Parameter ms updated by the RMSProp optimization algorithm.
+///   - mom: Parameter mom updated by the RMSProp optimization algorithm.
+///   - gradient_accumulators: Parameter gradient_accumulators updated by the RMSProp optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingRMSPropParametersGradAccumDebug(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> (parameters: Tensor<Float>, ms: Tensor<Float>, mom: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let op = TFE_Op("RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Retrieve SGD embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Output parameters: Parameter parameters updated by the stochastic gradient descent optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingStochasticGradientDescentParameters(
+  tableId: Int64 = -1,
+  tableName: String,
+  numShards: Int64,
+  shardId: Int64
+) -> Tensor<Float> {
+  let op = TFE_Op("RetrieveTPUEmbeddingStochasticGradientDescentParameters")
+  op.setAttr("table_id", tableId)
+  op.setAttr("table_name", tableName)
+  op.setAttr("num_shards", numShards)
+  op.setAttr("shard_id", shardId)
+  return op.execute(Int(1))
+}
+
+/// Reverses specific dimensions of a tensor.
+///
+/// Given a `tensor`, and a `bool` tensor `dims` representing the dimensions
+/// of `tensor`, this operation reverses each dimension i of `tensor` where
+/// `dims[i]` is `True`.
+///
+/// `tensor` can have up to 8 dimensions. The number of dimensions
+/// of `tensor` must equal the number of elements in `dims`. In other words:
+///
+/// `rank(tensor) = size(dims)`
+///
+/// For example:
+///
+/// ```
+/// # tensor 't' is [[[[ 0,  1,  2,  3],
+/// #                  [ 4,  5,  6,  7],
+/// #                  [ 8,  9, 10, 11]],
+/// #                 [[12, 13, 14, 15],
+/// #                  [16, 17, 18, 19],
+/// #                  [20, 21, 22, 23]]]]
+/// # tensor 't' shape is [1, 2, 3, 4]
+///
+/// # 'dims' is [False, False, False, True]
+/// reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
+///                         [ 7,  6,  5,  4],
+///                         [ 11, 10, 9, 8]],
+///                        [[15, 14, 13, 12],
+///                         [19, 18, 17, 16],
+///                         [23, 22, 21, 20]]]]
+///
+/// # 'dims' is [False, True, False, False]
+/// reverse(t, dims) ==> [[[[12, 13, 14, 15],
+///                         [16, 17, 18, 19],
+///                         [20, 21, 22, 23]
+///                        [[ 0,  1,  2,  3],
+///                         [ 4,  5,  6,  7],
+///                         [ 8,  9, 10, 11]]]]
+///
+/// # 'dims' is [False, False, True, False]
+/// reverse(t, dims) ==> [[[[8, 9, 10, 11],
+///                         [4, 5, 6, 7],
+///                         [0, 1, 2, 3]]
+///                        [[20, 21, 22, 23],
+///                         [16, 17, 18, 19],
+///                         [12, 13, 14, 15]]]]
+/// ```
+///
+/// - Parameters:
+///   - tensor: Up to 8-D.
+///   - dims: 1-D. The dimensions to reverse.
+///
+/// - Output output: The same shape as `tensor`.
+@inlinable @inline(__always)
+public static func reverse<T: TensorFlowScalar>(
+  _ tensor: Tensor<T>,
+  dims: Tensor<Bool>
+) -> Tensor<T> {
+  let op = TFE_Op("Reverse")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(dims)
+  return op.execute(Int(1))
+}
+
+/// Reverses specific dimensions of a tensor.
+///
+/// Given a `tensor`, and a `bool` tensor `dims` representing the dimensions
+/// of `tensor`, this operation reverses each dimension i of `tensor` where
+/// `dims[i]` is `True`.
+///
+/// `tensor` can have up to 8 dimensions. The number of dimensions
+/// of `tensor` must equal the number of elements in `dims`. In other words:
+///
+/// `rank(tensor) = size(dims)`
+///
+/// For example:
+///
+/// ```
+/// # tensor 't' is [[[[ 0,  1,  2,  3],
+/// #                  [ 4,  5,  6,  7],
+/// #                  [ 8,  9, 10, 11]],
+/// #                 [[12, 13, 14, 15],
+/// #                  [16, 17, 18, 19],
+/// #                  [20, 21, 22, 23]]]]
+/// # tensor 't' shape is [1, 2, 3, 4]
+///
+/// # 'dims' is [False, False, False, True]
+/// reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
+///                         [ 7,  6,  5,  4],
+///                         [ 11, 10, 9, 8]],
+///                        [[15, 14, 13, 12],
+///                         [19, 18, 17, 16],
+///                         [23, 22, 21, 20]]]]
+///
+/// # 'dims' is [False, True, False, False]
+/// reverse(t, dims) ==> [[[[12, 13, 14, 15],
+///                         [16, 17, 18, 19],
+///                         [20, 21, 22, 23]
+///                        [[ 0,  1,  2,  3],
+///                         [ 4,  5,  6,  7],
+///                         [ 8,  9, 10, 11]]]]
+///
+/// # 'dims' is [False, False, True, False]
+/// reverse(t, dims) ==> [[[[8, 9, 10, 11],
+///                         [4, 5, 6, 7],
+///                         [0, 1, 2, 3]]
+///                        [[20, 21, 22, 23],
+///                         [16, 17, 18, 19],
+///                         [12, 13, 14, 15]]]]
+/// ```
+///
+/// - Parameters:
+///   - tensor: Up to 8-D.
+///   - dims: 1-D. The dimensions to reverse.
+///
+/// - Output output: The same shape as `tensor`.
+@inlinable @inline(__always)
+public static func reverse(
+  _ tensor: StringTensor,
+  dims: Tensor<Bool>
+) -> StringTensor {
+  let op = TFE_Op("Reverse")
+  op.setAttr("T", TensorDataType(TF_STRING))
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(dims)
+  return op.execute(Int(1))
+}
+
+/// Reverses variable length slices.
+///
+/// This op first slices `input` along the dimension `batch_dim`, and for each
+/// slice `i`, reverses the first `seq_lengths[i]` elements along
+/// the dimension `seq_dim`.
+///
+/// The elements of `seq_lengths` must obey `seq_lengths[i] <= input.dims[seq_dim]`,
+/// and `seq_lengths` must be a vector of length `input.dims[batch_dim]`.
+///
+/// The output slice `i` along dimension `batch_dim` is then given by input
+/// slice `i`, with the first `seq_lengths[i]` slices along dimension
+/// `seq_dim` reversed.
+///
+/// For example:
+///
+/// ```
+/// # Given this:
+/// batch_dim = 0
+/// seq_dim = 1
+/// input.dims = (4, 8, ...)
+/// seq_lengths = [7, 2, 3, 5]
+///
+/// # then slices of input are reversed on seq_dim, but only up to seq_lengths:
+/// output[0, 0:7, :, ...] = input[0, 7:0:-1, :, ...]
+/// output[1, 0:2, :, ...] = input[1, 2:0:-1, :, ...]
+/// output[2, 0:3, :, ...] = input[2, 3:0:-1, :, ...]
+/// output[3, 0:5, :, ...] = input[3, 5:0:-1, :, ...]
+///
+/// # while entries past seq_lens are copied through:
+/// output[0, 7:, :, ...] = input[0, 7:, :, ...]
+/// output[1, 2:, :, ...] = input[1, 2:, :, ...]
+/// output[2, 3:, :, ...] = input[2, 3:, :, ...]
+/// output[3, 2:, :, ...] = input[3, 2:, :, ...]
+/// ```
+///
+/// In contrast, if:
+///
+/// ```
+/// # Given this:
+/// batch_dim = 2
+/// seq_dim = 0
+/// input.dims = (8, ?, 4, ...)
+/// seq_lengths = [7, 2, 3, 5]
+///
+/// # then slices of input are reversed on seq_dim, but only up to seq_lengths:
+/// output[0:7, :, 0, :, ...] = input[7:0:-1, :, 0, :, ...]
+/// output[0:2, :, 1, :, ...] = input[2:0:-1, :, 1, :, ...]
+/// output[0:3, :, 2, :, ...] = input[3:0:-1, :, 2, :, ...]
+/// output[0:5, :, 3, :, ...] = input[5:0:-1, :, 3, :, ...]
+///
+/// # while entries past seq_lens are copied through:
+/// output[7:, :, 0, :, ...] = input[7:, :, 0, :, ...]
+/// output[2:, :, 1, :, ...] = input[2:, :, 1, :, ...]
+/// output[3:, :, 2, :, ...] = input[3:, :, 2, :, ...]
+/// output[2:, :, 3, :, ...] = input[2:, :, 3, :, ...]
+/// ```
+///
+/// - Parameters:
+///   - input: The input to reverse.
+///   - seq_lengths: 1-D with length `input.dims(batch_dim)` and
+///     `max(seq_lengths) <= input.dims(seq_dim)`
+///
+/// - Attrs:
+///   - seq_dim: The dimension which is partially reversed.
+///   - batch_dim: The dimension along which reversal is performed.
+///
+/// - Output output: The partially reversed input. It has the same shape as `input`.
+@inlinable @inline(__always)
+public static func reverseSequence<
+    T: TensorFlowScalar,
+    Tlen: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  seqLengths: Tensor<Tlen>,
+  seqDim: Int64,
+  batchDim: Int64 = 0
+) -> Tensor<T> {
+  let op = TFE_Op("ReverseSequence")
+  op.setAttr("seq_dim", seqDim)
+  op.setAttr("batch_dim", batchDim)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tlen", Tlen.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(seqLengths)
+  return op.execute(Int(1))
+}
+
+/// Reverses specific dimensions of a tensor.
+///
+/// NOTE `tf.reverse` has now changed behavior in preparation for 1.0.
+/// `tf.reverse_v2` is currently an alias that will be deprecated before TF 1.0.
+///
+/// Given a `tensor`, and a `int32` tensor `axis` representing the set of
+/// dimensions of `tensor` to reverse. This operation reverses each dimension
+/// `i` for which there exists `j` s.t. `axis[j] == i`.
+///
+/// `tensor` can have up to 8 dimensions. The number of dimensions specified
+/// in `axis` may be 0 or more entries. If an index is specified more than
+/// once, a InvalidArgument error is raised.
+///
+/// For example:
+///
+/// ```
+/// # tensor 't' is [[[[ 0,  1,  2,  3],
+/// #                  [ 4,  5,  6,  7],
+/// #                  [ 8,  9, 10, 11]],
+/// #                 [[12, 13, 14, 15],
+/// #                  [16, 17, 18, 19],
+/// #                  [20, 21, 22, 23]]]]
+/// # tensor 't' shape is [1, 2, 3, 4]
+///
+/// # 'dims' is [3] or 'dims' is [-1]
+/// reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
+///                         [ 7,  6,  5,  4],
+///                         [ 11, 10, 9, 8]],
+///                        [[15, 14, 13, 12],
+///                         [19, 18, 17, 16],
+///                         [23, 22, 21, 20]]]]
+///
+/// # 'dims' is '[1]' (or 'dims' is '[-3]')
+/// reverse(t, dims) ==> [[[[12, 13, 14, 15],
+///                         [16, 17, 18, 19],
+///                         [20, 21, 22, 23]
+///                        [[ 0,  1,  2,  3],
+///                         [ 4,  5,  6,  7],
+///                         [ 8,  9, 10, 11]]]]
+///
+/// # 'dims' is '[2]' (or 'dims' is '[-2]')
+/// reverse(t, dims) ==> [[[[8, 9, 10, 11],
+///                         [4, 5, 6, 7],
+///                         [0, 1, 2, 3]]
+///                        [[20, 21, 22, 23],
+///                         [16, 17, 18, 19],
+///                         [12, 13, 14, 15]]]]
+/// ```
+///
+/// - Parameters:
+///   - tensor: Up to 8-D.
+///   - axis: 1-D. The indices of the dimensions to reverse. Must be in the range
+///     `[-rank(tensor), rank(tensor))`.
+///
+/// - Output output: The same shape as `tensor`.
+@inlinable @inline(__always)
+public static func reverseV2<
+    Tidx: BinaryInteger & TensorFlowScalar,
+    T: TensorFlowScalar
+>(
+  _ tensor: Tensor<T>,
+  axis: Tensor<Tidx>
+) -> Tensor<T> {
+  let op = TFE_Op("ReverseV2")
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(axis)
+  return op.execute(Int(1))
+}
+
+/// Reverses specific dimensions of a tensor.
+///
+/// NOTE `tf.reverse` has now changed behavior in preparation for 1.0.
+/// `tf.reverse_v2` is currently an alias that will be deprecated before TF 1.0.
+///
+/// Given a `tensor`, and a `int32` tensor `axis` representing the set of
+/// dimensions of `tensor` to reverse. This operation reverses each dimension
+/// `i` for which there exists `j` s.t. `axis[j] == i`.
+///
+/// `tensor` can have up to 8 dimensions. The number of dimensions specified
+/// in `axis` may be 0 or more entries. If an index is specified more than
+/// once, a InvalidArgument error is raised.
+///
+/// For example:
+///
+/// ```
+/// # tensor 't' is [[[[ 0,  1,  2,  3],
+/// #                  [ 4,  5,  6,  7],
+/// #                  [ 8,  9, 10, 11]],
+/// #                 [[12, 13, 14, 15],
+/// #                  [16, 17, 18, 19],
+/// #                  [20, 21, 22, 23]]]]
+/// # tensor 't' shape is [1, 2, 3, 4]
+///
+/// # 'dims' is [3] or 'dims' is [-1]
+/// reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
+///                         [ 7,  6,  5,  4],
+///                         [ 11, 10, 9, 8]],
+///                        [[15, 14, 13, 12],
+///                         [19, 18, 17, 16],
+///                         [23, 22, 21, 20]]]]
+///
+/// # 'dims' is '[1]' (or 'dims' is '[-3]')
+/// reverse(t, dims) ==> [[[[12, 13, 14, 15],
+///                         [16, 17, 18, 19],
+///                         [20, 21, 22, 23]
+///                        [[ 0,  1,  2,  3],
+///                         [ 4,  5,  6,  7],
+///                         [ 8,  9, 10, 11]]]]
+///
+/// # 'dims' is '[2]' (or 'dims' is '[-2]')
+/// reverse(t, dims) ==> [[[[8, 9, 10, 11],
+///                         [4, 5, 6, 7],
+///                         [0, 1, 2, 3]]
+///                        [[20, 21, 22, 23],
+///                         [16, 17, 18, 19],
+///                         [12, 13, 14, 15]]]]
+/// ```
+///
+/// - Parameters:
+///   - tensor: Up to 8-D.
+///   - axis: 1-D. The indices of the dimensions to reverse. Must be in the range
+///     `[-rank(tensor), rank(tensor))`.
+///
+/// - Output output: The same shape as `tensor`.
+@inlinable @inline(__always)
+public static func reverseV2<Tidx: BinaryInteger & TensorFlowScalar>(
+  _ tensor: StringTensor,
+  axis: Tensor<Tidx>
+) -> StringTensor {
+  let op = TFE_Op("ReverseV2")
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  op.setAttr("T", TensorDataType(TF_STRING))
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(axis)
+  return op.execute(Int(1))
+}
+
+/// Elementwise computes the bitwise right-shift of `x` and `y`.
+///
+/// Performs a logical shift for unsigned integer types, and an arithmetic shift
+/// for signed integer types.
+///
+/// If `y` is negative, or greater than or equal to than the width of `x` in bits
+/// the result is implementation defined.
+@inlinable @inline(__always)
+public static func rightShift<T: BinaryInteger & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("RightShift")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns element-wise integer closest to x.
+///
+/// If the result is midway between two representable values,
+/// the even representable is chosen.
+/// For example:
+///
+/// ```
+/// rint(-1.5) ==> -2.0
+/// rint(0.5000001) ==> 1.0
+/// rint([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) ==> [-2., -2., -0., 0., 2., 2., 2.]
+/// ```
+@inlinable @inline(__always)
+public static func rint<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Rint")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Rolls the elements of a tensor along an axis.
+///
+/// The elements are shifted positively (towards larger indices) by the offset of
+/// `shift` along the dimension of `axis`. Negative `shift` values will shift
+/// elements in the opposite direction. Elements that roll passed the last position
+/// will wrap around to the first and vice versa. Multiple shifts along multiple
+/// axes may be specified.
+///
+/// For example:
+///
+/// ```
+/// # 't' is [0, 1, 2, 3, 4]
+/// roll(t, shift=2, axis=0) ==> [3, 4, 0, 1, 2]
+///
+/// # shifting along multiple dimensions
+/// # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
+/// roll(t, shift=[1, -2], axis=[0, 1]) ==> [[7, 8, 9, 5, 6], [2, 3, 4, 0, 1]]
+///
+/// # shifting along the same axis multiple times
+/// # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
+/// roll(t, shift=[2, -3], axis=[1, 1]) ==> [[1, 2, 3, 4, 0], [6, 7, 8, 9, 5]]
+/// ```
+///
+/// - Parameters:
+///   - shift: Dimension must be 0-D or 1-D. `shift[i]` specifies the number of places by which
+///     elements are shifted positively (towards larger indices) along the dimension
+///     specified by `axis[i]`. Negative shifts will roll the elements in the opposite
+///     direction.
+///   - axis: Dimension must be 0-D or 1-D. `axis[i]` specifies the dimension that the shift
+///     `shift[i]` should occur. If the same axis is referenced more than once, the
+///     total shift for that axis will be the sum of all the shifts that belong to that
+///     axis.
+///
+/// - Output output: Has the same shape and size as the input. The elements are shifted
+///   positively (towards larger indices) by the offsets of `shift` along the
+///   dimensions of `axis`.
+@inlinable @inline(__always)
+public static func roll<
+    T: TensorFlowScalar,
+    Tshift: BinaryInteger & TensorFlowScalar,
+    Taxis: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  shift: Tensor<Tshift>,
+  axis: Tensor<Taxis>
+) -> Tensor<T> {
+  let op = TFE_Op("Roll")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tshift", Tshift.tensorFlowDataType)
+  op.setAttr("Taxis", Taxis.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(shift)
+  let _ = op.addInput(axis)
+  return op.execute(Int(1))
+}
+
+/// Rounds the values of a tensor to the nearest integer, element-wise.
+///
+/// Rounds half to even.  Also known as bankers rounding. If you want to round
+/// according to the current system rounding mode use std::cint.
+@inlinable @inline(__always)
+public static func round<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Round")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Perform batches of RPC requests.
+///
+/// This op asynchronously performs either a single RPC request, or a batch
+/// of requests.  RPC requests are defined by three main parameters:
+///
+///   - `address` (the host+port or BNS address of the request)
+///   - `method` (the RPC method name for the request)
+///   - `request` (the serialized proto string, or vector of strings,
+///      of the RPC request argument).
+///
+/// For example, if you have an RPC service running on port localhost:2345,
+/// and its interface is configured with the following proto declaration:
+///
+/// ```
+/// service MyService {
+///   rpc MyMethod(MyRequestProto) returns (MyResponseProto) {
+///   }
+/// };
+/// ```
+///
+/// then call this op with arguments:
+///
+/// ```
+/// address = "localhost:2345"
+/// method = "MyService/MyMethod"
+/// ```
+///
+/// The `request` tensor is a string tensor representing serialized `MyRequestProto`
+/// strings; and the output string tensor `response` will have the same shape
+/// and contain (upon successful completion) corresponding serialized
+/// `MyResponseProto` strings.
+///
+/// For example, to send a single, empty, `MyRequestProto`, call
+/// this op with `request = ""`.  To send 5 **parallel** empty requests,
+/// call this op with `request = ["", "", "", "", ""]`.
+///
+/// More generally, one can create a batch of `MyRequestProto` serialized protos
+/// from regular batched tensors using the `encode_proto` op, and convert
+/// the response `MyResponseProto` serialized protos to batched tensors
+/// using the `decode_proto` op.
+///
+/// **NOTE** Working with serialized proto strings is faster than instantiating
+/// actual proto objects in memory, so no performance degradation is expected
+/// compared to writing custom kernels for this workflow.
+///
+/// If the connection fails or the remote worker returns an error
+/// status, the op reraises this exception locally.
+///
+/// See the `TryRpc` op if you prefer to handle RPC failures manually in the graph.
+///
+/// - Parameters:
+///   - address: `0-D` or `1-D`.  The address (i.e. host_name:port) of the RPC server.
+///     If this tensor has more than 1 element, then multiple parallel rpc requests
+///     are sent.  This argument broadcasts with `method` and `request`.
+///   - method: `0-D` or `1-D`.  The method address on the RPC server.
+///     If this tensor has more than 1 element, then multiple parallel rpc requests
+///     are sent.  This argument broadcasts with `address` and `request`.
+///   - request: `0-D` or `1-D`.  Serialized proto strings: the rpc request argument.
+///     If this tensor has more than 1 element, then multiple parallel rpc requests
+///     are sent.  This argument broadcasts with `address` and `method`.
+///
+/// - Attrs:
+///   - protocol: RPC protocol to use.  Empty string means use the default protocol.
+///     Options include 'grpc'.
+///   - fail_fast: `boolean`. If `true` (default), then failures to connect
+///     (i.e., the server does not immediately respond) cause an RPC failure.
+///   - timeout_in_ms: `int`. If `0` (default), then the kernel will run the RPC
+///     request and only time out if the RPC deadline passes or the session times out.
+///     If this value is greater than `0`, then the op will raise an exception if
+///     the RPC takes longer than `timeout_in_ms`.
+///
+/// - Output response: Same shape as `request`. Serialized proto strings: the rpc responses.
+@inlinable @inline(__always)
+public static func rpc(
+  address: StringTensor,
+  method: StringTensor,
+  request: StringTensor,
+  protocol_: String,
+  failFast: Bool = true,
+  timeoutInMs: Int64 = 0
+) -> StringTensor {
+  let op = TFE_Op("Rpc")
+  op.setAttr("protocol", protocol_)
+  op.setAttr("fail_fast", failFast)
+  op.setAttr("timeout_in_ms", timeoutInMs)
+  let _ = op.addInput(address)
+  let _ = op.addInput(method)
+  let _ = op.addInput(request)
+  return op.execute(Int(1))
+}
+
+/// Computes reciprocal of square root of x element-wise.
+///
+/// I.e., \\(y = 1 / \sqrt{x}\\).
+@inlinable @inline(__always)
+public static func rsqrt<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Rsqrt")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient for the rsqrt of `x` wrt its input.
+///
+/// Specifically, `grad = dy * -0.5 * y^3`, where `y = rsqrt(x)`, and `dy`
+/// is the corresponding input gradient.
+@inlinable @inline(__always)
+public static func rsqrtGrad<T: FloatingPoint & TensorFlowScalar>(
+  _ y: Tensor<T>,
+  dy: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("RsqrtGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(y)
+  let _ = op.addInput(dy)
+  return op.execute(Int(1))
+}
+
+/// Generate a single randomly distorted bounding box for an image.
+///
+/// Bounding box annotations are often supplied in addition to ground-truth labels
+/// in image recognition or object localization tasks. A common technique for
+/// training such a system is to randomly distort an image while preserving
+/// its content, i.e. *data augmentation*. This Op outputs a randomly distorted
+/// localization of an object, i.e. bounding box, given an `image_size`,
+/// `bounding_boxes` and a series of constraints.
+///
+/// The output of this Op is a single bounding box that may be used to crop the
+/// original image. The output is returned as 3 tensors: `begin`, `size` and
+/// `bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the
+/// image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize
+/// what the bounding box looks like.
+///
+/// Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The
+/// bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
+/// height of the underlying image.
+///
+/// For example,
+///
+/// ```python
+///     # Generate a single distorted bounding box.
+///     begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
+///         tf.shape(image),
+///         bounding_boxes=bounding_boxes)
+///
+///     # Draw the bounding box in an image summary.
+///     image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0),
+///                                                   bbox_for_draw)
+///     tf.summary.image('images_with_box', image_with_box)
+///
+///     # Employ the bounding box to distort the image.
+///     distorted_image = tf.slice(image, begin, size)
+/// ```
+///
+/// Note that if no bounding box information is available, setting
+/// `use_image_if_no_bounding_boxes = true` will assume there is a single implicit
+/// bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is
+/// false and no bounding boxes are supplied, an error is raised.
+///
+/// - Parameters:
+///   - image_size: 1-D, containing `[height, width, channels]`.
+///   - bounding_boxes: 3-D with shape `[batch, N, 4]` describing the N bounding boxes
+///     associated with the image.
+///
+/// - Attrs:
+///   - seed: If either `seed` or `seed2` are set to non-zero, the random number
+///     generator is seeded by the given `seed`.  Otherwise, it is seeded by a random
+///     seed.
+///   - seed2: A second seed to avoid seed collision.
+///   - min_object_covered: The cropped area of the image must contain at least this
+///     fraction of any bounding box supplied. The value of this parameter should be
+///     non-negative. In the case of 0, the cropped area does not need to overlap
+///     any of the bounding boxes supplied.
+///   - aspect_ratio_range: The cropped area of the image must have an aspect ratio =
+///     width / height within this range.
+///   - area_range: The cropped area of the image must contain a fraction of the
+///     supplied image within this range.
+///   - max_attempts: Number of attempts at generating a cropped region of the image
+///     of the specified constraints. After `max_attempts` failures, return the entire
+///     image.
+///   - use_image_if_no_bounding_boxes: Controls behavior if no bounding boxes supplied.
+///     If true, assume an implicit bounding box covering the whole input. If false,
+///     raise an error.
+///
+/// - Outputs:
+///   - begin: 1-D, containing `[offset_height, offset_width, 0]`. Provide as input to
+///     `tf.slice`.
+///   - size: 1-D, containing `[target_height, target_width, -1]`. Provide as input to
+///     `tf.slice`.
+///   - bboxes: 3-D with shape `[1, 1, 4]` containing the distorted bounding box.
+///     Provide as input to `tf.image.draw_bounding_boxes`.
+@inlinable @inline(__always)
+public static func sampleDistortedBoundingBox<T: BinaryInteger & TensorFlowScalar>(
+  imageSize: Tensor<T>,
+  boundingBoxes: Tensor<Float>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0,
+  minObjectCovered: Double = 0.1,
+  aspectRatioRange: [Double] = [0.75, 1.33],
+  areaRange: [Double] = [0.05, 1],
+  maxAttempts: Int64 = 100,
+  useImageIfNoBoundingBoxes: Bool = false
+) -> (begin: Tensor<T>, size: Tensor<T>, bboxes: Tensor<Float>) {
+  let op = TFE_Op("SampleDistortedBoundingBox")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("min_object_covered", minObjectCovered)
+  op.setAttr("aspect_ratio_range", aspectRatioRange)
+  op.setAttr("area_range", areaRange)
+  op.setAttr("max_attempts", maxAttempts)
+  op.setAttr("use_image_if_no_bounding_boxes", useImageIfNoBoundingBoxes)
+  let _ = op.addInput(imageSize)
+  let _ = op.addInput(boundingBoxes)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Generate a single randomly distorted bounding box for an image.
+///
+/// Bounding box annotations are often supplied in addition to ground-truth labels
+/// in image recognition or object localization tasks. A common technique for
+/// training such a system is to randomly distort an image while preserving
+/// its content, i.e. *data augmentation*. This Op outputs a randomly distorted
+/// localization of an object, i.e. bounding box, given an `image_size`,
+/// `bounding_boxes` and a series of constraints.
+///
+/// The output of this Op is a single bounding box that may be used to crop the
+/// original image. The output is returned as 3 tensors: `begin`, `size` and
+/// `bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the
+/// image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize
+/// what the bounding box looks like.
+///
+/// Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The
+/// bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
+/// height of the underlying image.
+///
+/// For example,
+///
+/// ```python
+///     # Generate a single distorted bounding box.
+///     begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
+///         tf.shape(image),
+///         bounding_boxes=bounding_boxes)
+///
+///     # Draw the bounding box in an image summary.
+///     image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0),
+///                                                   bbox_for_draw)
+///     tf.summary.image('images_with_box', image_with_box)
+///
+///     # Employ the bounding box to distort the image.
+///     distorted_image = tf.slice(image, begin, size)
+/// ```
+///
+/// Note that if no bounding box information is available, setting
+/// `use_image_if_no_bounding_boxes = true` will assume there is a single implicit
+/// bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is
+/// false and no bounding boxes are supplied, an error is raised.
+///
+/// - Parameters:
+///   - image_size: 1-D, containing `[height, width, channels]`.
+///   - bounding_boxes: 3-D with shape `[batch, N, 4]` describing the N bounding boxes
+///     associated with the image.
+///   - min_object_covered: The cropped area of the image must contain at least this
+///     fraction of any bounding box supplied. The value of this parameter should be
+///     non-negative. In the case of 0, the cropped area does not need to overlap
+///     any of the bounding boxes supplied.
+///
+/// - Attrs:
+///   - seed: If either `seed` or `seed2` are set to non-zero, the random number
+///     generator is seeded by the given `seed`.  Otherwise, it is seeded by a random
+///     seed.
+///   - seed2: A second seed to avoid seed collision.
+///   - aspect_ratio_range: The cropped area of the image must have an aspect ratio =
+///     width / height within this range.
+///   - area_range: The cropped area of the image must contain a fraction of the
+///     supplied image within this range.
+///   - max_attempts: Number of attempts at generating a cropped region of the image
+///     of the specified constraints. After `max_attempts` failures, return the entire
+///     image.
+///   - use_image_if_no_bounding_boxes: Controls behavior if no bounding boxes supplied.
+///     If true, assume an implicit bounding box covering the whole input. If false,
+///     raise an error.
+///
+/// - Outputs:
+///   - begin: 1-D, containing `[offset_height, offset_width, 0]`. Provide as input to
+///     `tf.slice`.
+///   - size: 1-D, containing `[target_height, target_width, -1]`. Provide as input to
+///     `tf.slice`.
+///   - bboxes: 3-D with shape `[1, 1, 4]` containing the distorted bounding box.
+///     Provide as input to `tf.image.draw_bounding_boxes`.
+@inlinable @inline(__always)
+public static func sampleDistortedBoundingBoxV2<T: BinaryInteger & TensorFlowScalar>(
+  imageSize: Tensor<T>,
+  boundingBoxes: Tensor<Float>,
+  minObjectCovered: Tensor<Float>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0,
+  aspectRatioRange: [Double] = [0.75, 1.33],
+  areaRange: [Double] = [0.05, 1],
+  maxAttempts: Int64 = 100,
+  useImageIfNoBoundingBoxes: Bool = false
+) -> (begin: Tensor<T>, size: Tensor<T>, bboxes: Tensor<Float>) {
+  let op = TFE_Op("SampleDistortedBoundingBoxV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("aspect_ratio_range", aspectRatioRange)
+  op.setAttr("area_range", areaRange)
+  op.setAttr("max_attempts", maxAttempts)
+  op.setAttr("use_image_if_no_bounding_boxes", useImageIfNoBoundingBoxes)
+  let _ = op.addInput(imageSize)
+  let _ = op.addInput(boundingBoxes)
+  let _ = op.addInput(minObjectCovered)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Creates a dataset that contains `rate` elements from the `input_dataset`.
+///
+/// - Parameters:
+///   - rate: A scalar representing the sample rate of elements from the `input_dataset`
+///     that should be taken.
+///   - seed: A scalar representing seed of random number generator.
+///   - seed2: A scalar representing seed2 of random number generator.
+@inlinable @inline(__always)
+public static func samplingDataset(
+  inputDataset: VariantHandle,
+  rate: Tensor<Float>,
+  seed: Tensor<Int64>,
+  seed2: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("SamplingDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(rate)
+  let _ = op.addInput(seed)
+  let _ = op.addInput(seed2)
+  return op.execute(Int(1))
+}
+
+/// Saves the input tensors to disk.
+///
+/// The size of `tensor_names` must match the number of tensors in `data`. `data[i]`
+/// is written to `filename` with name `tensor_names[i]`.
+///
+/// See also `SaveSlices`.
+///
+/// - Parameters:
+///   - filename: Must have a single element. The name of the file to which we write
+///     the tensor.
+///   - tensor_names: Shape `[N]`. The names of the tensors to be saved.
+///   - data: `N` tensors to save.
+@inlinable @inline(__always)
+public static func save<T: TensorArrayProtocol>(
+  filename: StringTensor,
+  tensorNames: StringTensor,
+  data: T
+) {
+  let op = TFE_Op("Save")
+  op.setAttr("T", data._typeList)
+  let _ = op.addInput(filename)
+  let _ = op.addInput(tensorNames)
+  let _ = op.addInputList(data)
+  op.execute()
+}
+
+/// Saves input tensors slices to disk.
+///
+/// This is like `Save` except that tensors can be listed in the saved file as being
+/// a slice of a larger tensor.  `shapes_and_slices` specifies the shape of the
+/// larger tensor and the slice that this tensor covers. `shapes_and_slices` must
+/// have as many elements as `tensor_names`.
+///
+/// Elements of the `shapes_and_slices` input must either be:
+///
+/// *  The empty string, in which case the corresponding tensor is
+///    saved normally.
+/// *  A string of the form `dim0 dim1 ... dimN-1 slice-spec` where the
+///    `dimI` are the dimensions of the larger tensor and `slice-spec`
+///    specifies what part is covered by the tensor to save.
+///
+/// `slice-spec` itself is a `:`-separated list: `slice0:slice1:...:sliceN-1`
+/// where each `sliceI` is either:
+///
+/// *  The string `-` meaning that the slice covers all indices of this dimension
+/// *  `start,length` where `start` and `length` are integers.  In that
+///    case the slice covers `length` indices starting at `start`.
+///
+/// See also `Save`.
+///
+/// - Parameters:
+///   - filename: Must have a single element. The name of the file to which we write the
+///     tensor.
+///   - tensor_names: Shape `[N]`. The names of the tensors to be saved.
+///   - shapes_and_slices: Shape `[N]`.  The shapes and slice specifications to use when
+///     saving the tensors.
+///   - data: `N` tensors to save.
+@inlinable @inline(__always)
+public static func saveSlices<T: TensorArrayProtocol>(
+  filename: StringTensor,
+  tensorNames: StringTensor,
+  shapesAndSlices: StringTensor,
+  data: T
+) {
+  let op = TFE_Op("SaveSlices")
+  op.setAttr("T", data._typeList)
+  let _ = op.addInput(filename)
+  let _ = op.addInput(tensorNames)
+  let _ = op.addInput(shapesAndSlices)
+  let _ = op.addInputList(data)
+  op.execute()
+}
+
+/// Saves tensors in V2 checkpoint format.
+///
+/// By default, saves the named tensors in full.  If the caller wishes to save
+/// specific slices of full tensors, "shape_and_slices" should be non-empty strings
+/// and correspondingly well-formed.
+///
+/// - Parameters:
+///   - prefix: Must have a single element. The prefix of the V2 checkpoint to which we
+///     write the tensors.
+///   - tensor_names: shape {N}. The names of the tensors to be saved.
+///   - shape_and_slices: shape {N}.  The slice specs of the tensors to be saved.
+///     Empty strings indicate that they are non-partitioned tensors.
+///   - tensors: `N` tensors to save.
+@inlinable @inline(__always)
+public static func saveV2<Dtypes: TensorArrayProtocol>(
+  prefix: StringTensor,
+  tensorNames: StringTensor,
+  shapeAndSlices: StringTensor,
+  tensors: Dtypes
+) {
+  let op = TFE_Op("SaveV2")
+  op.setAttr("dtypes", tensors._typeList)
+  let _ = op.addInput(prefix)
+  let _ = op.addInput(tensorNames)
+  let _ = op.addInput(shapeAndSlices)
+  let _ = op.addInputList(tensors)
+  op.execute()
+}
+
+/// Outputs a `Summary` protocol buffer with scalar values.
+///
+/// The input `tags` and `values` must have the same shape.  The generated summary
+/// has a summary value for each tag-value pair in `tags` and `values`.
+///
+/// - Parameters:
+///   - tags: Tags for the summary.
+///   - values: Same shape as `tags.  Values for the summary.
+///
+/// - Output summary: Scalar.  Serialized `Summary` protocol buffer.
+@inlinable @inline(__always)
+public static func scalarSummary<T: Numeric & TensorFlowScalar>(
+  tags: StringTensor,
+  _ values: Tensor<T>
+) -> StringTensor {
+  let op = TFE_Op("ScalarSummary")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(tags)
+  let _ = op.addInput(values)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func scaleAndTranslate<T: Numeric & TensorFlowScalar>(
+  images: Tensor<T>,
+  size: Tensor<Int32>,
+  scale: Tensor<Float>,
+  translation: Tensor<Float>,
+  kernelType: String = "lanczos3",
+  antialias: Bool = true
+) -> Tensor<Float> {
+  let op = TFE_Op("ScaleAndTranslate")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("kernel_type", kernelType)
+  op.setAttr("antialias", antialias)
+  let _ = op.addInput(images)
+  let _ = op.addInput(size)
+  let _ = op.addInput(scale)
+  let _ = op.addInput(translation)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func scaleAndTranslateGrad<T: FloatingPoint & TensorFlowScalar>(
+  grads: Tensor<T>,
+  originalImage: Tensor<T>,
+  scale: Tensor<Float>,
+  translation: Tensor<Float>,
+  kernelType: String = "lanczos3",
+  antialias: Bool = true
+) -> Tensor<T> {
+  let op = TFE_Op("ScaleAndTranslateGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("kernel_type", kernelType)
+  op.setAttr("antialias", antialias)
+  let _ = op.addInput(grads)
+  let _ = op.addInput(originalImage)
+  let _ = op.addInput(scale)
+  let _ = op.addInput(translation)
+  return op.execute(Int(1))
+}
+
+/// Scatter `updates` into a new tensor according to `indices`.
+///
+/// Creates a new tensor by applying sparse `updates` to individual values or
+/// slices within a tensor (initially zero for numeric, empty for string) of
+/// the given `shape` according to indices.  This operator is the inverse of the
+/// `tf.gather_nd` operator which extracts values or slices from a given tensor.
+///
+/// This operation is similar to tensor_scatter_add, except that the tensor is
+/// zero-initialized. Calling `tf.scatter_nd(indices, values, shape)` is identical
+/// to `tensor_scatter_add(tf.zeros(shape, values.dtype), indices, values)`
+///
+/// If `indices` contains duplicates, then their updates are accumulated (summed).
+///
+/// **WARNING**: The order in which updates are applied is nondeterministic, so the
+/// output will be nondeterministic if `indices` contains duplicates -- because
+/// of some numerical approximation issues, numbers summed in different order
+/// may yield different results.
+///
+/// `indices` is an integer tensor containing indices into a new tensor of shape
+/// `shape`.  The last dimension of `indices` can be at most the rank of `shape`:
+///
+///     indices.shape[-1] <= shape.rank
+///
+/// The last dimension of `indices` corresponds to indices into elements
+/// (if `indices.shape[-1] = shape.rank`) or slices
+/// (if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
+/// `shape`.  `updates` is a tensor with shape
+///
+///     indices.shape[:-1] + shape[indices.shape[-1]:]
+///
+/// The simplest form of scatter is to insert individual elements in a tensor by
+/// index. For example, say we want to insert 4 scattered elements in a rank-1
+/// tensor with 8 elements.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd1.png" alt>
+/// </div>
+///
+/// In Python, this scatter operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[4], [3], [1], [7]])
+///     updates = tf.constant([9, 10, 11, 12])
+///     shape = tf.constant([8])
+///     scatter = tf.scatter_nd(indices, updates, shape)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [0, 11, 0, 10, 9, 0, 0, 12]
+///
+/// We can also, insert entire slices of a higher rank tensor all at once. For
+/// example, if we wanted to insert two slices in the first dimension of a
+/// rank-3 tensor with two matrices of new values.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd2.png" alt>
+/// </div>
+///
+/// In Python, this scatter operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[0], [2]])
+///     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]],
+///                            [[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]]])
+///     shape = tf.constant([4, 4, 4])
+///     scatter = tf.scatter_nd(indices, updates, shape)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+///      [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
+///      [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+///      [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]]
+///
+/// Note that on CPU, if an out of bound index is found, an error is returned.
+/// On GPU, if an out of bound index is found, the index is ignored.
+///
+/// - Parameters:
+///   - indices: Index tensor.
+///   - updates: Updates to scatter into output.
+///   - shape: 1-D. The shape of the resulting tensor.
+///
+/// - Output output: A new tensor with the given shape and updates applied according
+///   to the indices.
+@inlinable @inline(__always)
+public static func scatterNd<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  indices: Tensor<Tindices>,
+  updates: Tensor<T>,
+  shape: Tensor<Tindices>
+) -> Tensor<T> {
+  let op = TFE_Op("ScatterNd")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Applies sparse addition to `input` using individual values or slices
+///
+/// from `updates` according to indices `indices`.  The updates are non-aliasing:
+/// `input` is only modified in-place if no other operations will use it.
+/// Otherwise, a copy of `input` is made.  This operation has a gradient with
+/// respect to both `input` and `updates`.
+///
+/// `input` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+///
+/// `indices` must be integer tensor, containing indices into `input`.
+/// It must be shape \\([d_0, ..., d_{Q-2}, K]\\) where `0 < K <= P`.
+///
+/// The innermost dimension of `indices` (with length `K`) corresponds to
+/// indices into elements (if `K = P`) or `(P-K)`-dimensional slices
+/// (if `K < P`) along the `K`th dimension of `input`.
+///
+/// `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+///
+/// $$[d_0, ..., d_{Q-2}, input.shape[K], ..., input.shape[P-1]].$$
+///
+/// For example, say we want to add 4 scattered elements to a rank-1 tensor to 8
+/// elements. In Python, that addition would look like this:
+///
+///     input = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
+///     indices = tf.constant([[4], [3], [1], [7]])
+///     updates = tf.constant([9, 10, 11, 12])
+///     output = tf.scatter_nd_non_aliasing_add(input, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(output))
+///
+/// The resulting value `output` would look like this:
+///
+///     [1, 13, 3, 14, 14, 6, 7, 20]
+///
+/// See `tf.scatter_nd` for more details about how to make updates to slices.
+///
+/// - Parameters:
+///   - input: A Tensor.
+///   - indices: A Tensor. Must be one of the following types: `int32`, `int64`.
+///     A tensor of indices into `input`.
+///   - updates: A Tensor. Must have the same type as ref. A tensor of updated values
+///     to add to `input`.
+///
+/// - Output output: A `Tensor` with the same shape as `input`, containing values of `input`
+///   updated with `updates`.
+@inlinable @inline(__always)
+public static func scatterNdNonAliasingAdd<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  indices: Tensor<Tindices>,
+  updates: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("ScatterNdNonAliasingAdd")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  return op.execute(Int(1))
+}
+
+/// Computes fingerprints of the input strings.
+///
+/// - Parameter input: vector of strings to compute fingerprints on.
+///
+/// - Output output: a (N,2) shaped matrix where N is the number of elements in the input
+///   vector. Each row contains the low and high parts of the fingerprint.
+@inlinable @inline(__always)
+public static func sdcaFprint(
+  _ input: StringTensor
+) -> Tensor<Int64> {
+  let op = TFE_Op("SdcaFprint")
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Distributed version of Stochastic Dual Coordinate Ascent (SDCA) optimizer for
+///
+/// linear models with L1 + L2 regularization. As global optimization objective is
+/// strongly-convex, the optimizer optimizes the dual objective at each step. The
+/// optimizer applies each update one example at a time. Examples are sampled
+/// uniformly, and the optimizer is learning rate free and enjoys linear convergence
+/// rate.
+///
+/// [Proximal Stochastic Dual Coordinate Ascent](http://arxiv.org/pdf/1211.2717v1.pdf).<br>
+/// Shai Shalev-Shwartz, Tong Zhang. 2012
+///
+/// $$Loss Objective = \sum f_{i} (wx_{i}) + (l2 / 2) * |w|^2 + l1 * |w|$$
+///
+/// [Adding vs. Averaging in Distributed Primal-Dual Optimization](http://arxiv.org/abs/1502.03508).<br>
+/// Chenxin Ma, Virginia Smith, Martin Jaggi, Michael I. Jordan,
+/// Peter Richtarik, Martin Takac. 2015
+///
+/// [Stochastic Dual Coordinate Ascent with Adaptive Probabilities](https://arxiv.org/abs/1502.08053).<br>
+/// Dominik Csiba, Zheng Qu, Peter Richtarik. 2015
+///
+/// - Parameters:
+///   - sparse_example_indices: a list of vectors which contain example indices.
+///   - sparse_feature_indices: a list of vectors which contain feature indices.
+///   - sparse_feature_values: a list of vectors which contains feature value
+///     associated with each feature group.
+///   - dense_features: a list of matrices which contains the dense feature values.
+///   - example_weights: a vector which contains the weight associated with each
+///     example.
+///   - example_labels: a vector which contains the label/target associated with each
+///     example.
+///   - sparse_indices: a list of vectors where each value is the indices which has
+///     corresponding weights in sparse_weights. This field maybe omitted for the
+///     dense approach.
+///   - sparse_weights: a list of vectors where each value is the weight associated with
+///     a sparse feature group.
+///   - dense_weights: a list of vectors where the values are the weights associated
+///     with a dense feature group.
+///   - example_state_data: a list of vectors containing the example state data.
+///
+/// - Attrs:
+///   - loss_type: Type of the primal loss. Currently SdcaSolver supports logistic,
+///     squared and hinge losses.
+///   - adaptative: Whether to use Adaptive SDCA for the inner loop.
+///   - num_sparse_features: Number of sparse feature groups to train on.
+///   - num_sparse_features_with_values: Number of sparse feature groups with values
+///     associated with it, otherwise implicitly treats values as 1.0.
+///   - num_dense_features: Number of dense feature groups to train on.
+///   - l1: Symmetric l1 regularization strength.
+///   - l2: Symmetric l2 regularization strength.
+///   - num_loss_partitions: Number of partitions of the global loss function.
+///   - num_inner_iterations: Number of iterations per mini-batch.
+///
+/// - Outputs:
+///   - out_example_state_data: a list of vectors containing the updated example state
+///     data.
+///   - out_delta_sparse_weights: a list of vectors where each value is the delta
+///     weights associated with a sparse feature group.
+///   - out_delta_dense_weights: a list of vectors where the values are the delta
+///     weights associated with a dense feature group.
+@inlinable @inline(__always)
+public static func sdcaOptimizer(
+  sparseExampleIndices: [Tensor<Int64>],
+  sparseFeatureIndices: [Tensor<Int64>],
+  sparseFeatureValues: [Tensor<Float>],
+  denseFeatures: [Tensor<Float>],
+  exampleWeights: Tensor<Float>,
+  exampleLabels: Tensor<Float>,
+  sparseIndices: [Tensor<Int64>],
+  sparseWeights: [Tensor<Float>],
+  denseWeights: [Tensor<Float>],
+  exampleStateData: Tensor<Float>,
+  lossType: LossType,
+  adaptative: Bool = false,
+  l1: Double,
+  l2: Double,
+  numLossPartitions: Int64,
+  numInnerIterations: Int64
+) -> (outExampleStateData: Tensor<Float>, outDeltaSparseWeights: [Tensor<Float>], outDeltaDenseWeights: [Tensor<Float>]) {
+  let op = TFE_Op("SdcaOptimizer")
+  op.setAttr("loss_type", lossType.cName)
+  op.setAttr("adaptative", adaptative)
+  op.setAttr("num_sparse_features", sparseExampleIndices.count)
+  op.setAttr("num_sparse_features_with_values", sparseFeatureValues.count)
+  op.setAttr("num_dense_features", denseFeatures.count)
+  op.setAttr("l1", l1)
+  op.setAttr("l2", l2)
+  op.setAttr("num_loss_partitions", numLossPartitions)
+  op.setAttr("num_inner_iterations", numInnerIterations)
+  let _ = op.addInputList(sparseExampleIndices)
+  let _ = op.addInputList(sparseFeatureIndices)
+  let _ = op.addInputList(sparseFeatureValues)
+  let _ = op.addInputList(denseFeatures)
+  let _ = op.addInput(exampleWeights)
+  let _ = op.addInput(exampleLabels)
+  let _ = op.addInputList(sparseIndices)
+  let _ = op.addInputList(sparseWeights)
+  let _ = op.addInputList(denseWeights)
+  let _ = op.addInput(exampleStateData)
+  return op.execute(Int(1), Int(sparseExampleIndices.count), Int(denseFeatures.count))
+}
+
+/// Distributed version of Stochastic Dual Coordinate Ascent (SDCA) optimizer for
+///
+/// linear models with L1 + L2 regularization. As global optimization objective is
+/// strongly-convex, the optimizer optimizes the dual objective at each step. The
+/// optimizer applies each update one example at a time. Examples are sampled
+/// uniformly, and the optimizer is learning rate free and enjoys linear convergence
+/// rate.
+///
+/// [Proximal Stochastic Dual Coordinate Ascent](http://arxiv.org/pdf/1211.2717v1.pdf).<br>
+/// Shai Shalev-Shwartz, Tong Zhang. 2012
+///
+/// $$Loss Objective = \sum f_{i} (wx_{i}) + (l2 / 2) * |w|^2 + l1 * |w|$$
+///
+/// [Adding vs. Averaging in Distributed Primal-Dual Optimization](http://arxiv.org/abs/1502.03508).<br>
+/// Chenxin Ma, Virginia Smith, Martin Jaggi, Michael I. Jordan,
+/// Peter Richtarik, Martin Takac. 2015
+///
+/// [Stochastic Dual Coordinate Ascent with Adaptive Probabilities](https://arxiv.org/abs/1502.08053).<br>
+/// Dominik Csiba, Zheng Qu, Peter Richtarik. 2015
+///
+/// - Parameters:
+///   - sparse_example_indices: a list of vectors which contain example indices.
+///   - sparse_feature_indices: a list of vectors which contain feature indices.
+///   - sparse_feature_values: a list of vectors which contains feature value
+///     associated with each feature group.
+///   - dense_features: a list of matrices which contains the dense feature values.
+///   - example_weights: a vector which contains the weight associated with each
+///     example.
+///   - example_labels: a vector which contains the label/target associated with each
+///     example.
+///   - sparse_indices: a list of vectors where each value is the indices which has
+///     corresponding weights in sparse_weights. This field maybe omitted for the
+///     dense approach.
+///   - sparse_weights: a list of vectors where each value is the weight associated with
+///     a sparse feature group.
+///   - dense_weights: a list of vectors where the values are the weights associated
+///     with a dense feature group.
+///   - example_state_data: a list of vectors containing the example state data.
+///
+/// - Attrs:
+///   - loss_type: Type of the primal loss. Currently SdcaSolver supports logistic,
+///     squared and hinge losses.
+///   - adaptive: Whether to use Adaptive SDCA for the inner loop.
+///   - num_sparse_features: Number of sparse feature groups to train on.
+///   - num_sparse_features_with_values: Number of sparse feature groups with values
+///     associated with it, otherwise implicitly treats values as 1.0.
+///   - num_dense_features: Number of dense feature groups to train on.
+///   - l1: Symmetric l1 regularization strength.
+///   - l2: Symmetric l2 regularization strength.
+///   - num_loss_partitions: Number of partitions of the global loss function.
+///   - num_inner_iterations: Number of iterations per mini-batch.
+///
+/// - Outputs:
+///   - out_example_state_data: a list of vectors containing the updated example state
+///     data.
+///   - out_delta_sparse_weights: a list of vectors where each value is the delta
+///     weights associated with a sparse feature group.
+///   - out_delta_dense_weights: a list of vectors where the values are the delta
+///     weights associated with a dense feature group.
+@inlinable @inline(__always)
+public static func sdcaOptimizerV2(
+  sparseExampleIndices: [Tensor<Int64>],
+  sparseFeatureIndices: [Tensor<Int64>],
+  sparseFeatureValues: [Tensor<Float>],
+  denseFeatures: [Tensor<Float>],
+  exampleWeights: Tensor<Float>,
+  exampleLabels: Tensor<Float>,
+  sparseIndices: [Tensor<Int64>],
+  sparseWeights: [Tensor<Float>],
+  denseWeights: [Tensor<Float>],
+  exampleStateData: Tensor<Float>,
+  lossType: LossType,
+  adaptive: Bool = false,
+  l1: Double,
+  l2: Double,
+  numLossPartitions: Int64,
+  numInnerIterations: Int64
+) -> (outExampleStateData: Tensor<Float>, outDeltaSparseWeights: [Tensor<Float>], outDeltaDenseWeights: [Tensor<Float>]) {
+  let op = TFE_Op("SdcaOptimizerV2")
+  op.setAttr("loss_type", lossType.cName)
+  op.setAttr("adaptive", adaptive)
+  op.setAttr("num_sparse_features", sparseExampleIndices.count)
+  op.setAttr("num_sparse_features_with_values", sparseFeatureValues.count)
+  op.setAttr("num_dense_features", denseFeatures.count)
+  op.setAttr("l1", l1)
+  op.setAttr("l2", l2)
+  op.setAttr("num_loss_partitions", numLossPartitions)
+  op.setAttr("num_inner_iterations", numInnerIterations)
+  let _ = op.addInputList(sparseExampleIndices)
+  let _ = op.addInputList(sparseFeatureIndices)
+  let _ = op.addInputList(sparseFeatureValues)
+  let _ = op.addInputList(denseFeatures)
+  let _ = op.addInput(exampleWeights)
+  let _ = op.addInput(exampleLabels)
+  let _ = op.addInputList(sparseIndices)
+  let _ = op.addInputList(sparseWeights)
+  let _ = op.addInputList(denseWeights)
+  let _ = op.addInput(exampleStateData)
+  return op.execute(Int(1), Int(sparseExampleIndices.count), Int(denseFeatures.count))
+}
+
+/// Computes the maximum along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Computes a tensor such that
+/// \\(output_i = \max_j(data_j)\\) where `max` is over `j` such
+/// that `segment_ids[j] == i`.
+///
+/// If the max is empty for a given segment ID `i`, `output[i] = 0`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentMax.png" alt>
+/// </div>
+///
+/// For example:
+///
+/// ```
+/// c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
+/// tf.segment_max(c, tf.constant([0, 0, 1]))
+/// # ==> [[4, 3, 3, 4],
+/// #      [5, 6, 7, 8]]
+/// ```
+///
+///
+/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
+///   first dimension.  Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///   has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func segmentMax<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  segmentIds: Tensor<Tindices>
+) -> Tensor<T> {
+  let op = TFE_Op("SegmentMax")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(segmentIds)
+  return op.execute(Int(1))
+}
+
+/// Computes the mean along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Computes a tensor such that
+/// \\(output_i = \frac{\sum_j data_j}{N}\\) where `mean` is
+/// over `j` such that `segment_ids[j] == i` and `N` is the total number of
+/// values summed.
+///
+/// If the mean is empty for a given segment ID `i`, `output[i] = 0`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentMean.png" alt>
+/// </div>
+///
+/// For example:
+///
+/// ```
+/// c = tf.constant([[1.0,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
+/// tf.segment_mean(c, tf.constant([0, 0, 1]))
+/// # ==> [[2.5, 2.5, 2.5, 2.5],
+/// #      [5, 6, 7, 8]]
+/// ```
+///
+///
+/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
+///   first dimension.  Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///   has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func segmentMean<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  segmentIds: Tensor<Tindices>
+) -> Tensor<T> {
+  let op = TFE_Op("SegmentMean")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(segmentIds)
+  return op.execute(Int(1))
+}
+
+/// Computes the minimum along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Computes a tensor such that
+/// \\(output_i = \min_j(data_j)\\) where `min` is over `j` such
+/// that `segment_ids[j] == i`.
+///
+/// If the min is empty for a given segment ID `i`, `output[i] = 0`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentMin.png" alt>
+/// </div>
+///
+/// For example:
+///
+/// ```
+/// c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
+/// tf.segment_min(c, tf.constant([0, 0, 1]))
+/// # ==> [[1, 2, 2, 1],
+/// #      [5, 6, 7, 8]]
+/// ```
+///
+/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
+///   first dimension.  Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///   has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func segmentMin<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  segmentIds: Tensor<Tindices>
+) -> Tensor<T> {
+  let op = TFE_Op("SegmentMin")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(segmentIds)
+  return op.execute(Int(1))
+}
+
+/// Computes the product along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Computes a tensor such that
+/// \\(output_i = \prod_j data_j\\) where the product is over `j` such
+/// that `segment_ids[j] == i`.
+///
+/// If the product is empty for a given segment ID `i`, `output[i] = 1`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentProd.png" alt>
+/// </div>
+///
+/// For example:
+///
+/// ```
+/// c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
+/// tf.segment_prod(c, tf.constant([0, 0, 1]))
+/// # ==> [[4, 6, 6, 4],
+/// #      [5, 6, 7, 8]]
+/// ```
+///
+///
+/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
+///   first dimension.  Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///   has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func segmentProd<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  segmentIds: Tensor<Tindices>
+) -> Tensor<T> {
+  let op = TFE_Op("SegmentProd")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(segmentIds)
+  return op.execute(Int(1))
+}
+
+/// Computes the sum along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Computes a tensor such that
+/// \\(output_i = \sum_j data_j\\) where sum is over `j` such
+/// that `segment_ids[j] == i`.
+///
+/// If the sum is empty for a given segment ID `i`, `output[i] = 0`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentSum.png" alt>
+/// </div>
+///
+/// For example:
+///
+/// ```
+/// c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
+/// tf.segment_sum(c, tf.constant([0, 0, 1]))
+/// # ==> [[5, 5, 5, 5],
+/// #      [5, 6, 7, 8]]
+/// ```
+///
+///
+/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
+///   first dimension.  Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///   has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func segmentSum<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  segmentIds: Tensor<Tindices>
+) -> Tensor<T> {
+  let op = TFE_Op("SegmentSum")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(segmentIds)
+  return op.execute(Int(1))
+}
+
+/// Selects elements from `x` or `y`, depending on `condition`.
+///
+/// The `x`, and `y` tensors must all have the same shape, and the
+/// output will also have that shape.
+///
+/// The `condition` tensor must be a scalar if `x` and `y` are scalars.
+/// If `x` and `y` are vectors or higher rank, then `condition` must be either a
+/// scalar, a vector with size matching the first dimension of `x`, or must have
+/// the same shape as `x`.
+///
+/// The `condition` tensor acts as a mask that chooses, based on the value at each
+/// element, whether the corresponding element / row in the output should be
+/// taken from `x` (if true) or `y` (if false).
+///
+/// If `condition` is a vector and `x` and `y` are higher rank matrices, then
+/// it chooses which row (outer dimension) to copy from `x` and `y`.
+/// If `condition` has the same shape as `x` and `y`, then it chooses which
+/// element to copy from `x` and `y`.
+///
+/// For example:
+///
+/// ```python
+/// # 'condition' tensor is [[True,  False]
+/// #                        [False, True]]
+/// # 't' is [[1, 2],
+/// #         [3, 4]]
+/// # 'e' is [[5, 6],
+/// #         [7, 8]]
+/// select(condition, t, e)  # => [[1, 6], [7, 4]]
+///
+///
+/// # 'condition' tensor is [True, False]
+/// # 't' is [[1, 2],
+/// #         [3, 4]]
+/// # 'e' is [[5, 6],
+/// #         [7, 8]]
+/// select(condition, t, e) ==> [[1, 2],
+///                              [7, 8]]
+///
+/// ```
+///
+/// - Parameters:
+///   - t: = A `Tensor` which may have the same shape as `condition`.
+///     If `condition` is rank 1, `x` may have higher rank,
+///     but its first dimension must match the size of `condition`.
+///   - e: = A `Tensor` with the same type and shape as `x`.
+///
+/// - Output output: = A `Tensor` with the same type and shape as `x` and `y`.
+@inlinable @inline(__always)
+public static func select<T: TensorFlowScalar>(
+  condition: Tensor<Bool>,
+  t: Tensor<T>,
+  e: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Select")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(condition)
+  let _ = op.addInput(t)
+  let _ = op.addInput(e)
+  return op.execute(Int(1))
+}
+
+/// Computes the Eigen Decomposition of a batch of square self-adjoint matrices.
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices, with the same constraints as the single matrix
+/// SelfAdjointEig.
+///
+/// The result is a [..., M+1, M] matrix with [..., 0,:] containing the
+/// eigenvalues, and subsequent [...,1:, :] containing the eigenvectors. The eigenvalues
+/// are sorted in non-decreasing order.
+///
+/// - Parameter input: Shape is `[..., M, M]`.
+///
+/// - Output output: Shape is `[..., M+1, M]`.
+@inlinable @inline(__always)
+public static func selfAdjointEig<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("SelfAdjointEig")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Computes the eigen decomposition of one or more square self-adjoint matrices.
+///
+/// Computes the eigenvalues and (optionally) eigenvectors of each inner matrix in
+/// `input` such that `input[..., :, :] = v[..., :, :] * diag(e[..., :])`. The eigenvalues
+/// are sorted in non-decreasing order.
+///
+/// ```python
+/// # a is a tensor.
+/// # e is a tensor of eigenvalues.
+/// # v is a tensor of eigenvectors.
+/// e, v = self_adjoint_eig(a)
+/// e = self_adjoint_eig(a, compute_v=False)
+/// ```
+///
+/// - Parameter input: `Tensor` input of shape `[N, N]`.
+///
+/// - Attr compute_v: If `True` then eigenvectors will be computed and returned in `v`.
+///   Otherwise, only the eigenvalues will be computed.
+///
+/// - Outputs:
+///   - e: Eigenvalues. Shape is `[N]`.
+///   - v: Eigenvectors. Shape is `[N, N]`.
+@inlinable @inline(__always)
+public static func selfAdjointEigV2<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  computeV: Bool = true
+) -> (e: Tensor<T>, v: Tensor<T>) {
+  let op = TFE_Op("SelfAdjointEigV2")
+  op.setAttr("compute_v", computeV)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Computes scaled exponential linear: `scale * alpha * (exp(features) - 1)`
+///
+/// if < 0, `scale * features` otherwise.
+///
+/// To be used together with
+/// `initializer = tf.variance_scaling_initializer(factor=1.0, mode='FAN_IN')`.
+/// For correct dropout, use `tf.contrib.nn.alpha_dropout`.
+///
+/// See [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)
+@inlinable @inline(__always)
+public static func selu<T: FloatingPoint & TensorFlowScalar>(
+  features: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Selu")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(features)
+  return op.execute(Int(1))
+}
+
+/// Computes gradients for the scaled exponential linear (Selu) operation.
+///
+/// - Parameters:
+///   - gradients: The backpropagated gradients to the corresponding Selu operation.
+///   - outputs: The outputs of the corresponding Selu operation.
+///
+/// - Output backprops: The gradients: `gradients * (outputs + scale * alpha)`
+///   if outputs < 0, `scale * gradients` otherwise.
+@inlinable @inline(__always)
+public static func seluGrad<T: FloatingPoint & TensorFlowScalar>(
+  gradients: Tensor<T>,
+  outputs: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("SeluGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(gradients)
+  let _ = op.addInput(outputs)
+  return op.execute(Int(1))
+}
+
+/// Performs gradient updates of embedding tables.
+///
+/// - Parameters:
+///   - inputs: A TensorList of gradients with which to update embedding tables.
+///     This argument has the same length and shapes as the return value of
+///     RecvTPUEmbeddingActivations, but contains gradients of the model's loss
+///     with respect to the embedding activations. The embedding tables are updated
+///     from these gradients via the optimizer specified in the TPU embedding
+///     configuration given to tpu.initialize_system.
+///   - learning_rates: A TensorList of float32 scalars, one for each dynamic learning
+///     rate tag: see the comments in
+///     //third_party/tensorflow/core/protobuf/tpu/optimization_parameters.proto.
+///     Multiple tables can share the same dynamic learning rate tag as specified
+///     in the configuration. If the learning rates for all tables are constant,
+///     this list should be empty.
+///
+/// - Attr config: Serialized TPUEmbeddingConfiguration proto.
+@inlinable @inline(__always)
+public static func sendTPUEmbeddingGradients(
+  inputs: [Tensor<Float>],
+  learningRates: [Tensor<Float>],
+  config: String
+) {
+  let op = TFE_Op("SendTPUEmbeddingGradients")
+  op.setAttr("N", inputs.count)
+  op.setAttr("NN", learningRates.count)
+  op.setAttr("config", config)
+  let _ = op.addInputList(inputs)
+  let _ = op.addInputList(learningRates)
+  op.execute()
+}
+
+/// Converts the given `resource_handle` representing an iterator to a variant tensor.
+///
+/// - Parameter resource_handle: A handle to an iterator resource.
+///
+/// - Output serialized: A variant tensor storing the state of the iterator contained in the
+///   resource.
+@inlinable @inline(__always)
+public static func serializeIterator(
+  resourceHandle: ResourceHandle
+) -> VariantHandle {
+  let op = TFE_Op("SerializeIterator")
+  let _ = op.addInput(resourceHandle)
+  return op.execute(Int(1))
+}
+
+/// Serialize an `N`-minibatch `SparseTensor` into an `[N, 3]` `Tensor` object.
+///
+/// The `SparseTensor` must have rank `R` greater than 1, and the first dimension
+/// is treated as the minibatch dimension.  Elements of the `SparseTensor`
+/// must be sorted in increasing order of this first dimension.  The serialized
+/// `SparseTensor` objects going into each row of `serialized_sparse` will have
+/// rank `R-1`.
+///
+/// The minibatch size `N` is extracted from `sparse_shape[0]`.
+///
+/// - Parameters:
+///   - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
+///   - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
+///   - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
+///
+/// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
+///   (default) and `variant`.
+@inlinable @inline(__always)
+public static func serializeManySparse<
+    T: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  sparseIndices: Tensor<Int64>,
+  sparseValues: Tensor<T>,
+  sparseShape: Tensor<Int64>
+) -> Tensor<OutType> {
+  let op = TFE_Op("SerializeManySparse")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(sparseIndices)
+  let _ = op.addInput(sparseValues)
+  let _ = op.addInput(sparseShape)
+  return op.execute(Int(1))
+}
+
+/// Serialize an `N`-minibatch `SparseTensor` into an `[N, 3]` `Tensor` object.
+///
+/// The `SparseTensor` must have rank `R` greater than 1, and the first dimension
+/// is treated as the minibatch dimension.  Elements of the `SparseTensor`
+/// must be sorted in increasing order of this first dimension.  The serialized
+/// `SparseTensor` objects going into each row of `serialized_sparse` will have
+/// rank `R-1`.
+///
+/// The minibatch size `N` is extracted from `sparse_shape[0]`.
+///
+/// - Parameters:
+///   - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
+///   - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
+///   - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
+///
+/// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
+///   (default) and `variant`.
+@inlinable @inline(__always)
+public static func serializeManySparse<T: TensorFlowScalar>(
+  sparseIndices: Tensor<Int64>,
+  sparseValues: Tensor<T>,
+  sparseShape: Tensor<Int64>
+) -> StringTensor {
+  let op = TFE_Op("SerializeManySparse")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_type", TensorDataType(TF_STRING))
+  let _ = op.addInput(sparseIndices)
+  let _ = op.addInput(sparseValues)
+  let _ = op.addInput(sparseShape)
+  return op.execute(Int(1))
+}
+
+/// Serialize a `SparseTensor` into a `[3]` `Tensor` object.
+///
+/// - Parameters:
+///   - sparse_indices: 2-D.  The `indices` of the `SparseTensor`.
+///   - sparse_values: 1-D.  The `values` of the `SparseTensor`.
+///   - sparse_shape: 1-D.  The `shape` of the `SparseTensor`.
+///
+/// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
+///   (default) and `variant`.
+@inlinable @inline(__always)
+public static func serializeSparse<
+    T: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+  sparseIndices: Tensor<Int64>,
+  sparseValues: Tensor<T>,
+  sparseShape: Tensor<Int64>
+) -> Tensor<OutType> {
+  let op = TFE_Op("SerializeSparse")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(sparseIndices)
+  let _ = op.addInput(sparseValues)
+  let _ = op.addInput(sparseShape)
+  return op.execute(Int(1))
+}
+
+/// Serialize a `SparseTensor` into a `[3]` `Tensor` object.
+///
+/// - Parameters:
+///   - sparse_indices: 2-D.  The `indices` of the `SparseTensor`.
+///   - sparse_values: 1-D.  The `values` of the `SparseTensor`.
+///   - sparse_shape: 1-D.  The `shape` of the `SparseTensor`.
+///
+/// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
+///   (default) and `variant`.
+@inlinable @inline(__always)
+public static func serializeSparse<T: TensorFlowScalar>(
+  sparseIndices: Tensor<Int64>,
+  sparseValues: Tensor<T>,
+  sparseShape: Tensor<Int64>
+) -> StringTensor {
+  let op = TFE_Op("SerializeSparse")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_type", TensorDataType(TF_STRING))
+  let _ = op.addInput(sparseIndices)
+  let _ = op.addInput(sparseValues)
+  let _ = op.addInput(sparseShape)
+  return op.execute(Int(1))
+}
+
+/// Transforms a Tensor into a serialized TensorProto proto.
+///
+/// - Parameter tensor: A Tensor of type `T`.
+///
+/// - Attr T: The type of the input tensor.
+///
+/// - Output serialized: A serialized TensorProto proto of the input tensor.
+@inlinable @inline(__always)
+public static func serializeTensor<T: TensorFlowScalar>(
+  _ tensor: Tensor<T>
+) -> StringTensor {
+  let op = TFE_Op("SerializeTensor")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(tensor)
+  return op.execute(Int(1))
+}
+
+/// Number of unique elements along last dimension of input `set`.
+///
+/// Input `set` is a `SparseTensor` represented by `set_indices`, `set_values`,
+/// and `set_shape`. The last dimension contains values in a set, duplicates are
+/// allowed but ignored.
+///
+/// If `validate_indices` is `True`, this op validates the order and range of `set`
+/// indices.
+///
+/// - Parameters:
+///   - set_indices: 2D `Tensor`, indices of a `SparseTensor`.
+///   - set_values: 1D `Tensor`, values of a `SparseTensor`.
+///   - set_shape: 1D `Tensor`, shape of a `SparseTensor`.
+///
+/// - Output size: For `set` ranked `n`, this is a `Tensor` with rank `n-1`, and the same 1st
+///   `n-1` dimensions as `set`. Each value is the number of unique elements in
+///   the corresponding `[0...n-1]` dimension of `set`.
+@inlinable @inline(__always)
+public static func setSize<T: BinaryInteger & TensorFlowScalar>(
+  setIndices: Tensor<Int64>,
+  setValues: Tensor<T>,
+  setShape: Tensor<Int64>,
+  validateIndices: Bool = true
+) -> Tensor<Int32> {
+  let op = TFE_Op("SetSize")
+  op.setAttr("validate_indices", validateIndices)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(setIndices)
+  let _ = op.addInput(setValues)
+  let _ = op.addInput(setShape)
+  return op.execute(Int(1))
+}
+
+/// Number of unique elements along last dimension of input `set`.
+///
+/// Input `set` is a `SparseTensor` represented by `set_indices`, `set_values`,
+/// and `set_shape`. The last dimension contains values in a set, duplicates are
+/// allowed but ignored.
+///
+/// If `validate_indices` is `True`, this op validates the order and range of `set`
+/// indices.
+///
+/// - Parameters:
+///   - set_indices: 2D `Tensor`, indices of a `SparseTensor`.
+///   - set_values: 1D `Tensor`, values of a `SparseTensor`.
+///   - set_shape: 1D `Tensor`, shape of a `SparseTensor`.
+///
+/// - Output size: For `set` ranked `n`, this is a `Tensor` with rank `n-1`, and the same 1st
+///   `n-1` dimensions as `set`. Each value is the number of unique elements in
+///   the corresponding `[0...n-1]` dimension of `set`.
+@inlinable @inline(__always)
+public static func setSize(
+  setIndices: Tensor<Int64>,
+  setValues: StringTensor,
+  setShape: Tensor<Int64>,
+  validateIndices: Bool = true
+) -> Tensor<Int32> {
+  let op = TFE_Op("SetSize")
+  op.setAttr("validate_indices", validateIndices)
+  op.setAttr("T", TensorDataType(TF_STRING))
+  let _ = op.addInput(setIndices)
+  let _ = op.addInput(setValues)
+  let _ = op.addInput(setShape)
+  return op.execute(Int(1))
+}
+
+/// Returns the shape of a tensor.
+///
+/// This operation returns a 1-D integer tensor representing the shape of `input`.
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
+/// shape(t) ==> [2, 2, 3]
+/// ```
+@inlinable @inline(__always)
+public static func shape<
+    T: TensorFlowScalar,
+    OutType: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>
+) -> Tensor<OutType> {
+  let op = TFE_Op("Shape")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Returns shape of tensors.
+///
+/// This operation returns N 1-D integer tensors representing shape of `input[i]s`.
+@inlinable @inline(__always)
+public static func shapeN<
+    T: TensorFlowScalar,
+    OutType: BinaryInteger & TensorFlowScalar
+>(
+  _ input: [Tensor<T>]
+) -> [Tensor<OutType>] {
+  let op = TFE_Op("ShapeN")
+  op.setAttr("N", input.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInputList(input)
+  return op.execute(Int(input.count))
+}
+
+/// Creates a `Dataset` that includes only 1/`num_shards` of this dataset.
+///
+/// - Parameters:
+///   - num_shards: An integer representing the number of shards operating in parallel.
+///   - index: An integer representing the current worker index.
+@inlinable @inline(__always)
+public static func shardDataset(
+  inputDataset: VariantHandle,
+  numShards: Tensor<Int64>,
+  index: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ShardDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(numShards)
+  let _ = op.addInput(index)
+  return op.execute(Int(1))
+}
+
+/// Generate a sharded filename. The filename is printf formatted as
+///
+///    %s-%05d-of-%05d, basename, shard, num_shards.
+@inlinable @inline(__always)
+public static func shardedFilename(
+  basename: StringTensor,
+  shard: Tensor<Int32>,
+  numShards: Tensor<Int32>
+) -> StringTensor {
+  let op = TFE_Op("ShardedFilename")
+  let _ = op.addInput(basename)
+  let _ = op.addInput(shard)
+  let _ = op.addInput(numShards)
+  return op.execute(Int(1))
+}
+
+/// Generate a glob pattern matching all sharded file names.
+@inlinable @inline(__always)
+public static func shardedFilespec(
+  basename: StringTensor,
+  numShards: Tensor<Int32>
+) -> StringTensor {
+  let op = TFE_Op("ShardedFilespec")
+  let _ = op.addInput(basename)
+  let _ = op.addInput(numShards)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that shuffles and repeats elements from `input_dataset`
+///
+/// pseudorandomly.
+///
+/// - Parameters:
+///   - buffer_size: The number of output elements to buffer in an iterator over
+///     this dataset. Compare with the `min_after_dequeue` attr when creating a
+///     `RandomShuffleQueue`.
+///   - seed: A scalar seed for the random number generator. If either `seed` or
+///     `seed2` is set to be non-zero, the random number generator is seeded
+///     by the given seed.  Otherwise, a random seed is used.
+///   - seed2: A second scalar seed to avoid seed collision.
+///   - count: A scalar representing the number of times the underlying dataset
+///     should be repeated. The default is `-1`, which results in infinite repetition.
+@inlinable @inline(__always)
+public static func shuffleAndRepeatDataset(
+  inputDataset: VariantHandle,
+  bufferSize: Tensor<Int64>,
+  seed: Tensor<Int64>,
+  seed2: Tensor<Int64>,
+  count: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ShuffleAndRepeatDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(bufferSize)
+  let _ = op.addInput(seed)
+  let _ = op.addInput(seed2)
+  let _ = op.addInput(count)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that shuffles elements from `input_dataset` pseudorandomly.
+///
+/// - Parameters:
+///   - buffer_size: The number of output elements to buffer in an iterator over
+///     this dataset. Compare with the `min_after_dequeue` attr when creating a
+///     `RandomShuffleQueue`.
+///   - seed: A scalar seed for the random number generator. If either `seed` or
+///     `seed2` is set to be non-zero, the random number generator is seeded
+///     by the given seed.  Otherwise, a random seed is used.
+///   - seed2: A second scalar seed to avoid seed collision.
+///
+/// - Attr reshuffle_each_iteration: If true, each iterator over this dataset will be given
+///   a different pseudorandomly generated seed, based on a sequence seeded by the
+///   `seed` and `seed2` inputs. If false, each iterator will be given the same
+///   seed, and repeated iteration over this dataset will yield the exact same
+///   sequence of results.
+@inlinable @inline(__always)
+public static func shuffleDataset(
+  inputDataset: VariantHandle,
+  bufferSize: Tensor<Int64>,
+  seed: Tensor<Int64>,
+  seed2: Tensor<Int64>,
+  reshuffleEachIteration: Bool = true,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ShuffleDataset")
+  op.setAttr("reshuffle_each_iteration", reshuffleEachIteration)
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(bufferSize)
+  let _ = op.addInput(seed)
+  let _ = op.addInput(seed2)
+  return op.execute(Int(1))
+}
+
+/// Shuts down a running distributed TPU system.
+///
+/// The op returns an error if no system is running.
+@inlinable @inline(__always)
+public static func shutdownDistributedTPU(
+) {
+  let op = TFE_Op("ShutdownDistributedTPU")
+  
+  op.execute()
+}
+
+/// Computes sigmoid of `x` element-wise.
+///
+/// Specifically, `y = 1 / (1 + exp(-x))`.
+@inlinable @inline(__always)
+public static func sigmoid<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Sigmoid")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient of the sigmoid of `x` wrt its input.
+///
+/// Specifically, `grad = dy * y * (1 - y)`, where `y = sigmoid(x)`, and
+/// `dy` is the corresponding input gradient.
+@inlinable @inline(__always)
+public static func sigmoidGrad<T: FloatingPoint & TensorFlowScalar>(
+  _ y: Tensor<T>,
+  dy: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("SigmoidGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(y)
+  let _ = op.addInput(dy)
+  return op.execute(Int(1))
+}
+
+/// Returns an element-wise indication of the sign of a number.
+///
+/// `y = sign(x) = -1` if `x < 0`; 0 if `x == 0`; 1 if `x > 0`.
+///
+/// For complex numbers, `y = sign(x) = x / |x|` if `x != 0`, otherwise `y = 0`.
+@inlinable @inline(__always)
+public static func sign<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Sign")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func simple(
+  _ a: Tensor<Int32>
+) -> Tensor<Float> {
+  let op = TFE_Op("Simple")
+  let _ = op.addInput(a)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func simpleStruct(
+  nA: Int64
+) -> [Tensor<Int32>] {
+  let op = TFE_Op("SimpleStruct")
+  op.setAttr("n_a", nA)
+  return op.execute(Int(nA))
+}
+
+/// Computes sin of x element-wise.
+@inlinable @inline(__always)
+public static func sin<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Sin")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes hyperbolic sine of x element-wise.
+@inlinable @inline(__always)
+public static func sinh<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Sinh")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns the size of a tensor.
+///
+/// This operation returns an integer representing the number of elements in
+/// `input`.
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[[1, 1,, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]
+/// size(t) ==> 12
+/// ```
+@inlinable @inline(__always)
+public static func size<
+    T: TensorFlowScalar,
+    OutType: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>
+) -> Tensor<OutType> {
+  let op = TFE_Op("Size")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that skips `count` elements from the `input_dataset`.
+///
+/// - Parameter count: A scalar representing the number of elements from the `input_dataset`
+///   that should be skipped.  If count is -1, skips everything.
+@inlinable @inline(__always)
+public static func skipDataset(
+  inputDataset: VariantHandle,
+  count: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("SkipDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(count)
+  return op.execute(Int(1))
+}
+
+/// Parses a text file and creates a batch of examples.
+///
+/// - Attrs:
+///   - filename: The corpus's text file name.
+///   - batch_size: The size of produced batch.
+///   - window_size: The number of words to predict to the left and right of the target.
+///   - min_count: The minimum number of word occurrences for it to be included in the
+///     vocabulary.
+///   - subsample: Threshold for word occurrence. Words that appear with higher
+///     frequency will be randomly down-sampled. Set to 0 to disable.
+///
+/// - Outputs:
+///   - vocab_word: A vector of words in the corpus.
+///   - vocab_freq: Frequencies of words. Sorted in the non-ascending order.
+///   - words_per_epoch: Number of words per epoch in the data file.
+///   - current_epoch: The current epoch number.
+///   - total_words_processed: The total number of words processed so far.
+///   - examples: A vector of word ids.
+///   - labels: A vector of word ids.
+@inlinable @inline(__always)
+public static func skipgram(
+  filename: String,
+  batchSize: Int64,
+  windowSize: Int64 = 5,
+  minCount: Int64 = 5,
+  subsample: Double = 0.001
+) -> (vocabWord: StringTensor, vocabFreq: Tensor<Int32>, wordsPerEpoch: Tensor<Int64>, currentEpoch: Tensor<Int32>, totalWordsProcessed: Tensor<Int64>, examples: Tensor<Int32>, labels: Tensor<Int32>) {
+  let op = TFE_Op("Skipgram")
+  op.setAttr("filename", filename)
+  op.setAttr("batch_size", batchSize)
+  op.setAttr("window_size", windowSize)
+  op.setAttr("min_count", minCount)
+  op.setAttr("subsample", subsample)
+  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Return a slice from 'input'.
+///
+/// The output tensor is a tensor with dimensions described by 'size'
+/// whose values are extracted from 'input' starting at the offsets in
+/// 'begin'.
+///
+/// *Requirements*:
+///   0 <= begin[i] <= begin[i] + size[i] <= Di  for i in [0, n)
+///
+/// - Parameters:
+///   - begin: begin[i] specifies the offset into the 'i'th dimension of
+///     'input' to slice from.
+///   - size: size[i] specifies the number of elements of the 'i'th dimension
+///     of 'input' to slice. If size[i] is -1, all remaining elements in dimension
+///     i are included in the slice (i.e. this is equivalent to setting
+///     size[i] = input.dim_size(i) - begin[i]).
+@inlinable @inline(__always)
+public static func slice<
+    T: TensorFlowScalar,
+    Index: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  begin: Tensor<Index>,
+  size: Tensor<Index>
+) -> Tensor<T> {
+  let op = TFE_Op("Slice")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Index", Index.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(begin)
+  let _ = op.addInput(size)
+  return op.execute(Int(1))
+}
+
+/// Returns a copy of the input tensor.
+@inlinable @inline(__always)
+public static func snapshot<T: TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Snapshot")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Computes softmax activations.
+///
+/// For each batch `i` and class `j` we have
+///
+///     $$softmax[i, j] = exp(logits[i, j]) / sum_j(exp(logits[i, j]))$$
+///
+/// - Parameter logits: 2-D with shape `[batch_size, num_classes]`.
+///
+/// - Output softmax: Same shape as `logits`.
+@inlinable @inline(__always)
+public static func softmax<T: FloatingPoint & TensorFlowScalar>(
+  logits: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Softmax")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(logits)
+  return op.execute(Int(1))
+}
+
+/// Computes softmax cross entropy cost and gradients to backpropagate.
+///
+/// Inputs are the logits, not probabilities.
+///
+/// - Parameters:
+///   - features: batch_size x num_classes matrix
+///   - labels: batch_size x num_classes matrix
+///     The caller must ensure that each batch of labels represents a valid
+///     probability distribution.
+///
+/// - Outputs:
+///   - loss: Per example loss (batch_size vector).
+///   - backprop: backpropagated gradients (batch_size x num_classes matrix).
+@inlinable @inline(__always)
+public static func softmaxCrossEntropyWithLogits<T: FloatingPoint & TensorFlowScalar>(
+  features: Tensor<T>,
+  labels: Tensor<T>
+) -> (loss: Tensor<T>, backprop: Tensor<T>) {
+  let op = TFE_Op("SoftmaxCrossEntropyWithLogits")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(features)
+  let _ = op.addInput(labels)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Computes softplus: `log(exp(features) + 1)`.
+@inlinable @inline(__always)
+public static func softplus<T: FloatingPoint & TensorFlowScalar>(
+  features: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Softplus")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(features)
+  return op.execute(Int(1))
+}
+
+/// Computes softplus gradients for a softplus operation.
+///
+/// - Parameters:
+///   - gradients: The backpropagated gradients to the corresponding softplus operation.
+///   - features: The features passed as input to the corresponding softplus operation.
+///
+/// - Output backprops: The gradients: `gradients / (1 + exp(-features))`.
+@inlinable @inline(__always)
+public static func softplusGrad<T: FloatingPoint & TensorFlowScalar>(
+  gradients: Tensor<T>,
+  features: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("SoftplusGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(gradients)
+  let _ = op.addInput(features)
+  return op.execute(Int(1))
+}
+
+/// Computes softsign: `features / (abs(features) + 1)`.
+@inlinable @inline(__always)
+public static func softsign<T: FloatingPoint & TensorFlowScalar>(
+  features: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Softsign")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(features)
+  return op.execute(Int(1))
+}
+
+/// Computes softsign gradients for a softsign operation.
+///
+/// - Parameters:
+///   - gradients: The backpropagated gradients to the corresponding softsign operation.
+///   - features: The features passed as input to the corresponding softsign operation.
+///
+/// - Output backprops: The gradients: `gradients / (1 + abs(features)) ** 2`.
+@inlinable @inline(__always)
+public static func softsignGrad<T: FloatingPoint & TensorFlowScalar>(
+  gradients: Tensor<T>,
+  features: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("SoftsignGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(gradients)
+  let _ = op.addInput(features)
+  return op.execute(Int(1))
+}
+
+/// SpaceToBatch for 4-D tensors of type T.
+///
+/// This is a legacy version of the more general SpaceToBatchND.
+///
+/// Zero-pads and then rearranges (permutes) blocks of spatial data into batch.
+/// More specifically, this op outputs a copy of the input tensor where values from
+/// the `height` and `width` dimensions are moved to the `batch` dimension. After
+/// the zero-padding, both `height` and `width` of the input must be divisible by the
+/// block size.
+///
+/// - Parameters:
+///   - input: 4-D with shape `[batch, height, width, depth]`.
+///   - paddings: 2-D tensor of non-negative integers with shape `[2, 2]`. It specifies
+///       the padding of the input with zeros across the spatial dimensions as follows:
+///
+///           paddings = [[pad_top, pad_bottom], [pad_left, pad_right]]
+///
+///       The effective spatial dimensions of the zero-padded input tensor will be:
+///
+///           height_pad = pad_top + height + pad_bottom
+///           width_pad = pad_left + width + pad_right
+///
+///     The attr `block_size` must be greater than one. It indicates the block size.
+///
+///       * Non-overlapping blocks of size `block_size x block size` in the height and
+///         width dimensions are rearranged into the batch dimension at each location.
+///       * The batch of the output tensor is `batch * block_size * block_size`.
+///       * Both height_pad and width_pad must be divisible by block_size.
+///
+///     The shape of the output will be:
+///
+///         [batch*block_size*block_size, height_pad/block_size, width_pad/block_size,
+///          depth]
+///
+///     Some examples:
+///
+///     (1) For the following input of shape `[1, 2, 2, 1]` and block_size of 2:
+///
+///     ```
+///     x = [[[[1], [2]], [[3], [4]]]]
+///     ```
+///
+///     The output tensor has shape `[4, 1, 1, 1]` and value:
+///
+///     ```
+///     [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+///     ```
+///
+///     (2) For the following input of shape `[1, 2, 2, 3]` and block_size of 2:
+///
+///     ```
+///     x = [[[[1, 2, 3], [4, 5, 6]],
+///           [[7, 8, 9], [10, 11, 12]]]]
+///     ```
+///
+///     The output tensor has shape `[4, 1, 1, 3]` and value:
+///
+///     ```
+///     [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
+///     ```
+///
+///     (3) For the following input of shape `[1, 4, 4, 1]` and block_size of 2:
+///
+///     ```
+///     x = [[[[1],   [2],  [3],  [4]],
+///           [[5],   [6],  [7],  [8]],
+///           [[9],  [10], [11],  [12]],
+///           [[13], [14], [15],  [16]]]]
+///     ```
+///
+///     The output tensor has shape `[4, 2, 2, 1]` and value:
+///
+///     ```
+///     x = [[[[1], [3]], [[9], [11]]],
+///          [[[2], [4]], [[10], [12]]],
+///          [[[5], [7]], [[13], [15]]],
+///          [[[6], [8]], [[14], [16]]]]
+///     ```
+///
+///     (4) For the following input of shape `[2, 2, 4, 1]` and block_size of 2:
+///
+///     ```
+///     x = [[[[1],   [2],  [3],  [4]],
+///           [[5],   [6],  [7],  [8]]],
+///          [[[9],  [10], [11],  [12]],
+///           [[13], [14], [15],  [16]]]]
+///     ```
+///
+///     The output tensor has shape `[8, 1, 2, 1]` and value:
+///
+///     ```
+///     x = [[[[1], [3]]], [[[9], [11]]], [[[2], [4]]], [[[10], [12]]],
+///          [[[5], [7]]], [[[13], [15]]], [[[6], [8]]], [[[14], [16]]]]
+///     ```
+///
+///     Among others, this operation is useful for reducing atrous convolution into
+///     regular convolution.
+@inlinable @inline(__always)
+public static func spaceToBatch<
+    T: TensorFlowScalar,
+    Tpaddings: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  paddings: Tensor<Tpaddings>,
+  blockSize: Int64
+) -> Tensor<T> {
+  let op = TFE_Op("SpaceToBatch")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tpaddings", Tpaddings.tensorFlowDataType)
+  op.setAttr("block_size", blockSize)
+  let _ = op.addInput(input)
+  let _ = op.addInput(paddings)
+  return op.execute(Int(1))
+}
+
+/// SpaceToBatch for N-D tensors of type T.
+///
+/// This operation divides "spatial" dimensions `[1, ..., M]` of the input into a
+/// grid of blocks of shape `block_shape`, and interleaves these blocks with the
+/// "batch" dimension (0) such that in the output, the spatial dimensions
+/// `[1, ..., M]` correspond to the position within the grid, and the batch
+/// dimension combines both the position within a spatial block and the original
+/// batch position.  Prior to division into blocks, the spatial dimensions of the
+/// input are optionally zero padded according to `paddings`.  See below for a
+/// precise description.
+///
+/// - Parameters:
+///   - input: N-D with shape `input_shape = [batch] + spatial_shape + remaining_shape`,
+///     where spatial_shape has `M` dimensions.
+///   - block_shape: 1-D with shape `[M]`, all values must be >= 1.
+///   - paddings: 2-D with shape `[M, 2]`, all values must be >= 0.
+///       `paddings[i] = [pad_start, pad_end]` specifies the padding for input dimension
+///       `i + 1`, which corresponds to spatial dimension `i`.  It is required that
+///       `block_shape[i]` divides `input_shape[i + 1] + pad_start + pad_end`.
+///
+///     This operation is equivalent to the following steps:
+///
+///     1. Zero-pad the start and end of dimensions `[1, ..., M]` of the
+///        input according to `paddings` to produce `padded` of shape `padded_shape`.
+///
+///     2. Reshape `padded` to `reshaped_padded` of shape:
+///
+///          [batch] +
+///          [padded_shape[1] / block_shape[0],
+///            block_shape[0],
+///           ...,
+///           padded_shape[M] / block_shape[M-1],
+///           block_shape[M-1]] +
+///          remaining_shape
+///
+///     3. Permute dimensions of `reshaped_padded` to produce
+///        `permuted_reshaped_padded` of shape:
+///
+///          block_shape +
+///          [batch] +
+///          [padded_shape[1] / block_shape[0],
+///           ...,
+///           padded_shape[M] / block_shape[M-1]] +
+///          remaining_shape
+///
+///     4. Reshape `permuted_reshaped_padded` to flatten `block_shape` into the batch
+///        dimension, producing an output tensor of shape:
+///
+///          [batch * prod(block_shape)] +
+///          [padded_shape[1] / block_shape[0],
+///           ...,
+///           padded_shape[M] / block_shape[M-1]] +
+///          remaining_shape
+///
+///     Some examples:
+///
+///     (1) For the following input of shape `[1, 2, 2, 1]`, `block_shape = [2, 2]`, and
+///         `paddings = [[0, 0], [0, 0]]`:
+///
+///     ```
+///     x = [[[[1], [2]], [[3], [4]]]]
+///     ```
+///
+///     The output tensor has shape `[4, 1, 1, 1]` and value:
+///
+///     ```
+///     [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+///     ```
+///
+///     (2) For the following input of shape `[1, 2, 2, 3]`, `block_shape = [2, 2]`, and
+///         `paddings = [[0, 0], [0, 0]]`:
+///
+///     ```
+///     x = [[[[1, 2, 3], [4, 5, 6]],
+///           [[7, 8, 9], [10, 11, 12]]]]
+///     ```
+///
+///     The output tensor has shape `[4, 1, 1, 3]` and value:
+///
+///     ```
+///     [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
+///     ```
+///
+///     (3) For the following input of shape `[1, 4, 4, 1]`, `block_shape = [2, 2]`, and
+///         `paddings = [[0, 0], [0, 0]]`:
+///
+///     ```
+///     x = [[[[1],   [2],  [3],  [4]],
+///           [[5],   [6],  [7],  [8]],
+///           [[9],  [10], [11],  [12]],
+///           [[13], [14], [15],  [16]]]]
+///     ```
+///
+///     The output tensor has shape `[4, 2, 2, 1]` and value:
+///
+///     ```
+///     x = [[[[1], [3]], [[9], [11]]],
+///          [[[2], [4]], [[10], [12]]],
+///          [[[5], [7]], [[13], [15]]],
+///          [[[6], [8]], [[14], [16]]]]
+///     ```
+///
+///     (4) For the following input of shape `[2, 2, 4, 1]`, block_shape = `[2, 2]`, and
+///         paddings = `[[0, 0], [2, 0]]`:
+///
+///     ```
+///     x = [[[[1],   [2],  [3],  [4]],
+///           [[5],   [6],  [7],  [8]]],
+///          [[[9],  [10], [11],  [12]],
+///           [[13], [14], [15],  [16]]]]
+///     ```
+///
+///     The output tensor has shape `[8, 1, 3, 1]` and value:
+///
+///     ```
+///     x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
+///          [[[0], [2], [4]]], [[[0], [10], [12]]],
+///          [[[0], [5], [7]]], [[[0], [13], [15]]],
+///          [[[0], [6], [8]]], [[[0], [14], [16]]]]
+///     ```
+///
+///     Among others, this operation is useful for reducing atrous convolution into
+///     regular convolution.
+@inlinable @inline(__always)
+public static func spaceToBatchND<
+    T: TensorFlowScalar,
+    TblockShape: BinaryInteger & TensorFlowScalar,
+    Tpaddings: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  blockShape: Tensor<TblockShape>,
+  paddings: Tensor<Tpaddings>
+) -> Tensor<T> {
+  let op = TFE_Op("SpaceToBatchND")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tblock_shape", TblockShape.tensorFlowDataType)
+  op.setAttr("Tpaddings", Tpaddings.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(blockShape)
+  let _ = op.addInput(paddings)
+  return op.execute(Int(1))
+}
+
+/// SpaceToDepth for tensors of type T.
+///
+/// Rearranges blocks of spatial data, into depth. More specifically,
+/// this op outputs a copy of the input tensor where values from the `height`
+/// and `width` dimensions are moved to the `depth` dimension.
+/// The attr `block_size` indicates the input block size.
+///
+///   * Non-overlapping blocks of size `block_size x block size` are rearranged
+///     into depth at each location.
+///   * The depth of the output tensor is `block_size * block_size * input_depth`.
+///   * The Y, X coordinates within each block of the input become the high order
+///     component of the output channel index.
+///   * The input tensor's height and width must be divisible by block_size.
+///
+/// The `data_format` attr specifies the layout of the input and output tensors
+/// with the following options:
+///   "NHWC": `[ batch, height, width, channels ]`
+///   "NCHW": `[ batch, channels, height, width ]`
+///   "NCHW_VECT_C":
+///       `qint8 [ batch, channels / 4, height, width, 4 ]`
+///
+/// It is useful to consider the operation as transforming a 6-D Tensor.
+/// e.g. for data_format = NHWC,
+///      Each element in the input tensor can be specified via 6 coordinates,
+///      ordered by decreasing memory layout significance as:
+///      n,oY,bY,oX,bX,iC  (where n=batch index, oX, oY means X or Y coordinates
+///                         within the output image, bX, bY means coordinates
+///                         within the input block, iC means input channels).
+///      The output would be a transpose to the following layout:
+///      n,oY,oX,bY,bX,iC
+///
+/// This operation is useful for resizing the activations between convolutions
+/// (but keeping all data), e.g. instead of pooling. It is also useful for training
+/// purely convolutional models.
+///
+/// For example, given an input of shape `[1, 2, 2, 1]`, data_format = "NHWC" and
+/// block_size = 2:
+///
+/// ```
+/// x = [[[[1], [2]],
+///       [[3], [4]]]]
+/// ```
+///
+/// This operation will output a tensor of shape `[1, 1, 1, 4]`:
+///
+/// ```
+/// [[[[1, 2, 3, 4]]]]
+/// ```
+///
+/// Here, the input has a batch of 1 and each batch element has shape `[2, 2, 1]`,
+/// the corresponding output will have a single element (i.e. width and height are
+/// both 1) and will have a depth of 4 channels (1 * block_size * block_size).
+/// The output element shape is `[1, 1, 4]`.
+///
+/// For an input tensor with larger depth, here of shape `[1, 2, 2, 3]`, e.g.
+///
+/// ```
+/// x = [[[[1, 2, 3], [4, 5, 6]],
+///       [[7, 8, 9], [10, 11, 12]]]]
+/// ```
+///
+/// This operation, for block_size of 2, will return the following tensor of shape
+/// `[1, 1, 1, 12]`
+///
+/// ```
+/// [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
+/// ```
+///
+/// Similarly, for the following input of shape `[1 4 4 1]`, and a block size of 2:
+///
+/// ```
+/// x = [[[[1],   [2],  [5],  [6]],
+///       [[3],   [4],  [7],  [8]],
+///       [[9],  [10], [13],  [14]],
+///       [[11], [12], [15],  [16]]]]
+/// ```
+///
+/// the operator will return the following tensor of shape `[1 2 2 4]`:
+///
+/// ```
+/// x = [[[[1, 2, 3, 4],
+///        [5, 6, 7, 8]],
+///       [[9, 10, 11, 12],
+///        [13, 14, 15, 16]]]]
+/// ```
+///
+/// - Attr block_size: The size of the spatial block.
+@inlinable @inline(__always)
+public static func spaceToDepth<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  blockSize: Int64,
+  dataFormat: DataFormat4 = .nhwc
+) -> Tensor<T> {
+  let op = TFE_Op("SpaceToDepth")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("block_size", blockSize)
+  op.setAttr("data_format", dataFormat.cName)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Adds two `SparseTensor` objects to produce another `SparseTensor`.
+///
+/// The input `SparseTensor` objects' indices are assumed ordered in standard
+/// lexicographic order.  If this is not the case, before this step run
+/// `SparseReorder` to restore index ordering.
+///
+/// By default, if two values sum to zero at some index, the output `SparseTensor`
+/// would still include that particular location in its index, storing a zero in the
+/// corresponding value slot.  To override this, callers can specify `thresh`,
+/// indicating that if the sum has a magnitude strictly smaller than `thresh`, its
+/// corresponding value and index would then not be included.  In particular,
+/// `thresh == 0` (default) means everything is kept and actual thresholding happens
+/// only for a positive value.
+///
+/// In the following shapes, `nnz` is the count after taking `thresh` into account.
+///
+/// - Parameters:
+///   - a_indices: 2-D.  The `indices` of the first `SparseTensor`, size `[nnz, ndims]` Matrix.
+///   - a_values: 1-D.  The `values` of the first `SparseTensor`, size `[nnz]` Vector.
+///   - a_shape: 1-D.  The `shape` of the first `SparseTensor`, size `[ndims]` Vector.
+///   - b_indices: 2-D.  The `indices` of the second `SparseTensor`, size `[nnz, ndims]` Matrix.
+///   - b_values: 1-D.  The `values` of the second `SparseTensor`, size `[nnz]` Vector.
+///   - b_shape: 1-D.  The `shape` of the second `SparseTensor`, size `[ndims]` Vector.
+///   - thresh: 0-D.  The magnitude threshold that determines if an output value/index
+///     pair takes space.
+@inlinable @inline(__always)
+public static func sparseAdd<
+    T: Numeric & TensorFlowScalar,
+    Treal: Numeric & TensorFlowScalar
+>(
+  aIndices: Tensor<Int64>,
+  aValues: Tensor<T>,
+  aShape: Tensor<Int64>,
+  bIndices: Tensor<Int64>,
+  bValues: Tensor<T>,
+  bShape: Tensor<Int64>,
+  thresh: Tensor<Treal>
+) -> (sumIndices: Tensor<Int64>, sumValues: Tensor<T>, sumShape: Tensor<Int64>) {
+  let op = TFE_Op("SparseAdd")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Treal", Treal.tensorFlowDataType)
+  let _ = op.addInput(aIndices)
+  let _ = op.addInput(aValues)
+  let _ = op.addInput(aShape)
+  let _ = op.addInput(bIndices)
+  let _ = op.addInput(bValues)
+  let _ = op.addInput(bShape)
+  let _ = op.addInput(thresh)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// The gradient operator for the SparseAdd op.
+///
+/// The SparseAdd op calculates A + B, where A, B, and the sum are all represented
+/// as `SparseTensor` objects.  This op takes in the upstream gradient w.r.t.
+/// non-empty values of the sum, and outputs the gradients w.r.t. the non-empty
+/// values of A and B.
+///
+/// - Parameters:
+///   - backprop_val_grad: 1-D with shape `[nnz(sum)]`.  The gradient with respect to
+///     the non-empty values of the sum.
+///   - a_indices: 2-D.  The `indices` of the `SparseTensor` A, size `[nnz(A), ndims]`.
+///   - b_indices: 2-D.  The `indices` of the `SparseTensor` B, size `[nnz(B), ndims]`.
+///   - sum_indices: 2-D.  The `indices` of the sum `SparseTensor`, size
+///     `[nnz(sum), ndims]`.
+///
+/// - Outputs:
+///   - a_val_grad: 1-D with shape `[nnz(A)]`. The gradient with respect to the
+///     non-empty values of A.
+///   - b_val_grad: 1-D with shape `[nnz(B)]`. The gradient with respect to the
+///     non-empty values of B.
+@inlinable @inline(__always)
+public static func sparseAddGrad<T: Numeric & TensorFlowScalar>(
+  backpropValGrad: Tensor<T>,
+  aIndices: Tensor<Int64>,
+  bIndices: Tensor<Int64>,
+  sumIndices: Tensor<Int64>
+) -> (aValGrad: Tensor<T>, bValGrad: Tensor<T>) {
+  let op = TFE_Op("SparseAddGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(backpropValGrad)
+  let _ = op.addInput(aIndices)
+  let _ = op.addInput(bIndices)
+  let _ = op.addInput(sumIndices)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Concatenates a list of `SparseTensor` along the specified dimension.
+///
+/// Concatenation is with respect to the dense versions of these sparse tensors.
+/// It is assumed that each input is a `SparseTensor` whose elements are ordered
+/// along increasing dimension number.
+///
+/// All inputs' shapes must match, except for the concat dimension.  The
+/// `indices`, `values`, and `shapes` lists must have the same length.
+///
+/// The output shape is identical to the inputs', except along the concat
+/// dimension, where it is the sum of the inputs' sizes along that dimension.
+///
+/// The output elements will be resorted to preserve the sort order along
+/// increasing dimension number.
+///
+/// This op runs in `O(M log M)` time, where `M` is the total number of non-empty
+/// values across all inputs. This is due to the need for an internal sort in
+/// order to concatenate efficiently across an arbitrary dimension.
+///
+/// For example, if `concat_dim = 1` and the inputs are
+///
+///     sp_inputs[0]: shape = [2, 3]
+///     [0, 2]: "a"
+///     [1, 0]: "b"
+///     [1, 1]: "c"
+///
+///     sp_inputs[1]: shape = [2, 4]
+///     [0, 1]: "d"
+///     [0, 2]: "e"
+///
+/// then the output will be
+///
+///     shape = [2, 7]
+///     [0, 2]: "a"
+///     [0, 4]: "d"
+///     [0, 5]: "e"
+///     [1, 0]: "b"
+///     [1, 1]: "c"
+///
+/// Graphically this is equivalent to doing
+///
+///     [    a] concat [  d e  ] = [    a   d e  ]
+///     [b c  ]        [       ]   [b c          ]
+///
+/// - Parameters:
+///   - indices: 2-D.  Indices of each input `SparseTensor`.
+///   - values: 1-D.  Non-empty values of each `SparseTensor`.
+///   - shapes: 1-D.  Shapes of each `SparseTensor`.
+///
+/// - Attr concat_dim: Dimension to concatenate along. Must be in range [-rank, rank),
+///   where rank is the number of dimensions in each input `SparseTensor`.
+///
+/// - Outputs:
+///   - output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
+///   - output_values: 1-D.  Non-empty values of the concatenated `SparseTensor`.
+///   - output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
+@inlinable @inline(__always)
+public static func sparseConcat<T: TensorFlowScalar>(
+  indices: [Tensor<Int64>],
+  _ values: [Tensor<T>],
+  shapes: [Tensor<Int64>],
+  concatDim: Int64
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, outputShape: Tensor<Int64>) {
+  let op = TFE_Op("SparseConcat")
+  op.setAttr("concat_dim", concatDim)
+  op.setAttr("N", indices.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInputList(indices)
+  let _ = op.addInputList(values)
+  let _ = op.addInputList(shapes)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Generates sparse cross from a list of sparse and dense tensors.
+///
+/// The op takes two lists, one of 2D `SparseTensor` and one of 2D `Tensor`, each
+/// representing features of one feature column. It outputs a 2D `SparseTensor` with
+/// the batchwise crosses of these features.
+///
+/// For example, if the inputs are
+///
+///     inputs[0]: SparseTensor with shape = [2, 2]
+///     [0, 0]: "a"
+///     [1, 0]: "b"
+///     [1, 1]: "c"
+///
+///     inputs[1]: SparseTensor with shape = [2, 1]
+///     [0, 0]: "d"
+///     [1, 0]: "e"
+///
+///     inputs[2]: Tensor [["f"], ["g"]]
+///
+/// then the output will be
+///
+///     shape = [2, 2]
+///     [0, 0]: "a_X_d_X_f"
+///     [1, 0]: "b_X_e_X_g"
+///     [1, 1]: "c_X_e_X_g"
+///
+/// if hashed_output=true then the output will be
+///
+///     shape = [2, 2]
+///     [0, 0]: FingerprintCat64(
+///                 Fingerprint64("f"), FingerprintCat64(
+///                     Fingerprint64("d"), Fingerprint64("a")))
+///     [1, 0]: FingerprintCat64(
+///                 Fingerprint64("g"), FingerprintCat64(
+///                     Fingerprint64("e"), Fingerprint64("b")))
+///     [1, 1]: FingerprintCat64(
+///                 Fingerprint64("g"), FingerprintCat64(
+///                     Fingerprint64("e"), Fingerprint64("c")))
+///
+/// - Parameters:
+///   - indices: 2-D.  Indices of each input `SparseTensor`.
+///   - values: 1-D.   values of each `SparseTensor`.
+///   - shapes: 1-D.   Shapes of each `SparseTensor`.
+///   - dense_inputs: 2-D.    Columns represented by dense `Tensor`.
+///
+/// - Attrs:
+///   - hashed_output: If true, returns the hash of the cross instead of the string.
+///     This will allow us avoiding string manipulations.
+///   - num_buckets: It is used if hashed_output is true.
+///     output = hashed_value%num_buckets if num_buckets > 0 else hashed_value.
+///   - hash_key: Specify the hash_key that will be used by the `FingerprintCat64`
+///     function to combine the crosses fingerprints.
+///
+/// - Outputs:
+///   - output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
+///   - output_values: 1-D.  Non-empty values of the concatenated or hashed
+///     `SparseTensor`.
+///   - output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
+@inlinable @inline(__always)
+public static func sparseCross<
+    SparseTypes: TensorArrayProtocol,
+    DenseTypes: TensorArrayProtocol,
+    OutType: BinaryInteger & TensorFlowScalar
+>(
+  indices: [Tensor<Int64>],
+  _ values: SparseTypes,
+  shapes: [Tensor<Int64>],
+  denseInputs: DenseTypes,
+  hashedOutput: Bool,
+  numBuckets: Int64,
+  hashKey: Int64,
+  internalType: TensorDataType
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<OutType>, outputShape: Tensor<Int64>) {
+  let op = TFE_Op("SparseCross")
+  op.setAttr("N", indices.count)
+  op.setAttr("hashed_output", hashedOutput)
+  op.setAttr("num_buckets", numBuckets)
+  op.setAttr("hash_key", hashKey)
+  op.setAttr("sparse_types", values._typeList)
+  op.setAttr("dense_types", denseInputs._typeList)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  op.setAttr("internal_type", internalType)
+  let _ = op.addInputList(indices)
+  let _ = op.addInputList(values)
+  let _ = op.addInputList(shapes)
+  let _ = op.addInputList(denseInputs)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Generates sparse cross from a list of sparse and dense tensors.
+///
+/// The op takes two lists, one of 2D `SparseTensor` and one of 2D `Tensor`, each
+/// representing features of one feature column. It outputs a 2D `SparseTensor` with
+/// the batchwise crosses of these features.
+///
+/// For example, if the inputs are
+///
+///     inputs[0]: SparseTensor with shape = [2, 2]
+///     [0, 0]: "a"
+///     [1, 0]: "b"
+///     [1, 1]: "c"
+///
+///     inputs[1]: SparseTensor with shape = [2, 1]
+///     [0, 0]: "d"
+///     [1, 0]: "e"
+///
+///     inputs[2]: Tensor [["f"], ["g"]]
+///
+/// then the output will be
+///
+///     shape = [2, 2]
+///     [0, 0]: "a_X_d_X_f"
+///     [1, 0]: "b_X_e_X_g"
+///     [1, 1]: "c_X_e_X_g"
+///
+/// if hashed_output=true then the output will be
+///
+///     shape = [2, 2]
+///     [0, 0]: FingerprintCat64(
+///                 Fingerprint64("f"), FingerprintCat64(
+///                     Fingerprint64("d"), Fingerprint64("a")))
+///     [1, 0]: FingerprintCat64(
+///                 Fingerprint64("g"), FingerprintCat64(
+///                     Fingerprint64("e"), Fingerprint64("b")))
+///     [1, 1]: FingerprintCat64(
+///                 Fingerprint64("g"), FingerprintCat64(
+///                     Fingerprint64("e"), Fingerprint64("c")))
+///
+/// - Parameters:
+///   - indices: 2-D.  Indices of each input `SparseTensor`.
+///   - values: 1-D.   values of each `SparseTensor`.
+///   - shapes: 1-D.   Shapes of each `SparseTensor`.
+///   - dense_inputs: 2-D.    Columns represented by dense `Tensor`.
+///
+/// - Attrs:
+///   - hashed_output: If true, returns the hash of the cross instead of the string.
+///     This will allow us avoiding string manipulations.
+///   - num_buckets: It is used if hashed_output is true.
+///     output = hashed_value%num_buckets if num_buckets > 0 else hashed_value.
+///   - hash_key: Specify the hash_key that will be used by the `FingerprintCat64`
+///     function to combine the crosses fingerprints.
+///
+/// - Outputs:
+///   - output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
+///   - output_values: 1-D.  Non-empty values of the concatenated or hashed
+///     `SparseTensor`.
+///   - output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
+@inlinable @inline(__always)
+public static func sparseCross<
+    SparseTypes: TensorArrayProtocol,
+    DenseTypes: TensorArrayProtocol
+>(
+  indices: [Tensor<Int64>],
+  _ values: SparseTypes,
+  shapes: [Tensor<Int64>],
+  denseInputs: DenseTypes,
+  hashedOutput: Bool,
+  numBuckets: Int64,
+  hashKey: Int64,
+  internalType: TensorDataType
+) -> (outputIndices: Tensor<Int64>, outputValues: StringTensor, outputShape: Tensor<Int64>) {
+  let op = TFE_Op("SparseCross")
+  op.setAttr("N", indices.count)
+  op.setAttr("hashed_output", hashedOutput)
+  op.setAttr("num_buckets", numBuckets)
+  op.setAttr("hash_key", hashKey)
+  op.setAttr("sparse_types", values._typeList)
+  op.setAttr("dense_types", denseInputs._typeList)
+  op.setAttr("out_type", TensorDataType(TF_STRING))
+  op.setAttr("internal_type", internalType)
+  let _ = op.addInputList(indices)
+  let _ = op.addInputList(values)
+  let _ = op.addInputList(shapes)
+  let _ = op.addInputList(denseInputs)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Adds up a SparseTensor and a dense Tensor, using these special rules:
+///
+/// (1) Broadcasts the dense side to have the same shape as the sparse side, if
+///     eligible;
+/// (2) Then, only the dense values pointed to by the indices of the SparseTensor
+///     participate in the cwise addition.
+///
+/// By these rules, the result is a logical SparseTensor with exactly the same
+/// indices and shape, but possibly with different non-zero values.  The output of
+/// this Op is the resultant non-zero values.
+///
+/// - Parameters:
+///   - sp_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///     SparseTensor, possibly not in canonical ordering.
+///   - sp_values: 1-D.  `N` non-empty values corresponding to `sp_indices`.
+///   - sp_shape: 1-D.  Shape of the input SparseTensor.
+///   - dense: `R`-D.  The dense Tensor operand.
+///
+/// - Output output: 1-D.  The `N` values that are operated on.
+@inlinable @inline(__always)
+public static func sparseDenseCwiseAdd<T: Numeric & TensorFlowScalar>(
+  spIndices: Tensor<Int64>,
+  spValues: Tensor<T>,
+  spShape: Tensor<Int64>,
+  dense: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseDenseCwiseAdd")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(spIndices)
+  let _ = op.addInput(spValues)
+  let _ = op.addInput(spShape)
+  let _ = op.addInput(dense)
+  return op.execute(Int(1))
+}
+
+/// Component-wise divides a SparseTensor by a dense Tensor.
+///
+/// *Limitation*: this Op only broadcasts the dense side to the sparse side, but not
+/// the other direction.
+///
+/// - Parameters:
+///   - sp_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///     SparseTensor, possibly not in canonical ordering.
+///   - sp_values: 1-D.  `N` non-empty values corresponding to `sp_indices`.
+///   - sp_shape: 1-D.  Shape of the input SparseTensor.
+///   - dense: `R`-D.  The dense Tensor operand.
+///
+/// - Output output: 1-D.  The `N` values that are operated on.
+@inlinable @inline(__always)
+public static func sparseDenseCwiseDiv<T: Numeric & TensorFlowScalar>(
+  spIndices: Tensor<Int64>,
+  spValues: Tensor<T>,
+  spShape: Tensor<Int64>,
+  dense: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseDenseCwiseDiv")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(spIndices)
+  let _ = op.addInput(spValues)
+  let _ = op.addInput(spShape)
+  let _ = op.addInput(dense)
+  return op.execute(Int(1))
+}
+
+/// Component-wise multiplies a SparseTensor by a dense Tensor.
+///
+/// The output locations corresponding to the implicitly zero elements in the sparse
+/// tensor will be zero (i.e., will not take up storage space), regardless of the
+/// contents of the dense tensor (even if it's +/-INF and that INF*0 == NaN).
+///
+/// *Limitation*: this Op only broadcasts the dense side to the sparse side, but not
+/// the other direction.
+///
+/// - Parameters:
+///   - sp_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///     SparseTensor, possibly not in canonical ordering.
+///   - sp_values: 1-D.  `N` non-empty values corresponding to `sp_indices`.
+///   - sp_shape: 1-D.  Shape of the input SparseTensor.
+///   - dense: `R`-D.  The dense Tensor operand.
+///
+/// - Output output: 1-D.  The `N` values that are operated on.
+@inlinable @inline(__always)
+public static func sparseDenseCwiseMul<T: Numeric & TensorFlowScalar>(
+  spIndices: Tensor<Int64>,
+  spValues: Tensor<T>,
+  spShape: Tensor<Int64>,
+  dense: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseDenseCwiseMul")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(spIndices)
+  let _ = op.addInput(spValues)
+  let _ = op.addInput(spShape)
+  let _ = op.addInput(dense)
+  return op.execute(Int(1))
+}
+
+/// Fills empty rows in the input 2-D `SparseTensor` with a default value.
+///
+/// The input `SparseTensor` is represented via the tuple of inputs
+/// (`indices`, `values`, `dense_shape`).  The output `SparseTensor` has the
+/// same `dense_shape` but with indices `output_indices` and values
+/// `output_values`.
+///
+/// This op inserts a single entry for every row that doesn't have any values.
+/// The index is created as `[row, 0, ..., 0]` and the inserted value
+/// is `default_value`.
+///
+/// For example, suppose `sp_input` has shape `[5, 6]` and non-empty values:
+///
+///     [0, 1]: a
+///     [0, 3]: b
+///     [2, 0]: c
+///     [3, 1]: d
+///
+/// Rows 1 and 4 are empty, so the output will be of shape `[5, 6]` with values:
+///
+///     [0, 1]: a
+///     [0, 3]: b
+///     [1, 0]: default_value
+///     [2, 0]: c
+///     [3, 1]: d
+///     [4, 0]: default_value
+///
+/// The output `SparseTensor` will be in row-major order and will have the
+/// same shape as the input.
+///
+/// This op also returns an indicator vector shaped `[dense_shape[0]]` such that
+///
+///     empty_row_indicator[i] = True iff row i was an empty row.
+///
+/// And a reverse index map vector shaped `[indices.shape[0]]` that is used during
+/// backpropagation,
+///
+///     reverse_index_map[j] = out_j s.t. indices[j, :] == output_indices[out_j, :]
+///
+/// - Parameters:
+///   - indices: 2-D. the indices of the sparse tensor.
+///   - values: 1-D. the values of the sparse tensor.
+///   - dense_shape: 1-D. the shape of the sparse tensor.
+///   - default_value: 0-D. default value to insert into location `[row, 0, ..., 0]`
+///       for rows missing from the input sparse tensor.
+///     output indices: 2-D. the indices of the filled sparse tensor.
+///
+/// - Outputs:
+///   - output_values: 1-D. the values of the filled sparse tensor.
+///   - empty_row_indicator: 1-D. whether the dense row was missing in the
+///     input sparse tensor.
+///   - reverse_index_map: 1-D. a map from the input indices to the output indices.
+@inlinable @inline(__always)
+public static func sparseFillEmptyRows<T: TensorFlowScalar>(
+  indices: Tensor<Int64>,
+  _ values: Tensor<T>,
+  denseShape: Tensor<Int64>,
+  defaultValue: Tensor<T>
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, emptyRowIndicator: Tensor<Bool>, reverseIndexMap: Tensor<Int64>) {
+  let op = TFE_Op("SparseFillEmptyRows")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(values)
+  let _ = op.addInput(denseShape)
+  let _ = op.addInput(defaultValue)
+  return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// The gradient of SparseFillEmptyRows.
+///
+/// Takes vectors reverse_index_map, shaped `[N]`, and grad_values,
+/// shaped `[N_full]`, where `N_full >= N` and copies data into either
+/// `d_values` or `d_default_value`.  Here `d_values` is shaped `[N]` and
+/// `d_default_value` is a scalar.
+///
+///   d_values[j] = grad_values[reverse_index_map[j]]
+///   d_default_value = sum_{k : 0 .. N_full - 1} (
+///      grad_values[k] * 1{k not in reverse_index_map})
+///
+/// - Parameters:
+///   - reverse_index_map: 1-D.  The reverse index map from SparseFillEmptyRows.
+///   - grad_values: 1-D.  The gradients from backprop.
+///
+/// - Outputs:
+///   - d_values: 1-D.  The backprop into values.
+///   - d_default_value: 0-D.  The backprop into default_value.
+@inlinable @inline(__always)
+public static func sparseFillEmptyRowsGrad<T: TensorFlowScalar>(
+  reverseIndexMap: Tensor<Int64>,
+  gradValues: Tensor<T>
+) -> (dValues: Tensor<T>, dDefaultValue: Tensor<T>) {
+  let op = TFE_Op("SparseFillEmptyRowsGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(reverseIndexMap)
+  let _ = op.addInput(gradValues)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Multiply matrix "a" by matrix "b".
+///
+/// The inputs must be two-dimensional matrices and the inner dimension of "a" must
+/// match the outer dimension of "b". Both "a" and "b" must be `Tensor`s not
+/// `SparseTensor`s.  This op is optimized for the case where at least one of "a" or
+/// "b" is sparse, in the sense that they have a large proportion of zero values.
+/// The breakeven for using this versus a dense matrix multiply on one platform was
+/// 30% zero values in the sparse matrix.
+///
+/// The gradient computation of this operation will only take advantage of sparsity
+/// in the input gradient when that gradient comes from a Relu.
+@inlinable @inline(__always)
+public static func sparseMatMul<
+    Ta: FloatingPoint & TensorFlowScalar,
+    Tb: FloatingPoint & TensorFlowScalar
+>(
+  _ a: Tensor<Ta>,
+  _ b: Tensor<Tb>,
+  transposeA: Bool = false,
+  transposeB: Bool = false,
+  aIsSparse: Bool = false,
+  bIsSparse: Bool = false
+) -> Tensor<Float> {
+  let op = TFE_Op("SparseMatMul")
+  op.setAttr("transpose_a", transposeA)
+  op.setAttr("transpose_b", transposeB)
+  op.setAttr("a_is_sparse", aIsSparse)
+  op.setAttr("b_is_sparse", bIsSparse)
+  op.setAttr("Ta", Ta.tensorFlowDataType)
+  op.setAttr("Tb", Tb.tensorFlowDataType)
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  return op.execute(Int(1))
+}
+
+/// Computes the max of elements across dimensions of a SparseTensor.
+///
+/// This Op takes a SparseTensor and is the sparse counterpart to
+/// `tf.reduce_max()`.  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
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
+/// with length 1.
+///
+/// If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
+/// with a single element is returned.  Additionally, the axes can be negative,
+/// which are interpreted according to the indexing rules in Python.
+///
+/// - Parameters:
+///   - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///     SparseTensor, possibly not in canonical ordering.
+///   - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
+///   - input_shape: 1-D.  Shape of the input SparseTensor.
+///   - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: `R-K`-D.  The reduced Tensor.
+@inlinable @inline(__always)
+public static func sparseReduceMax<T: Numeric & TensorFlowScalar>(
+  inputIndices: Tensor<Int64>,
+  inputValues: Tensor<T>,
+  inputShape: Tensor<Int64>,
+  reductionAxes: Tensor<Int32>,
+  keepDims: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("SparseReduceMax")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(inputIndices)
+  let _ = op.addInput(inputValues)
+  let _ = op.addInput(inputShape)
+  let _ = op.addInput(reductionAxes)
+  return op.execute(Int(1))
+}
+
+/// Computes the max of elements across dimensions of a SparseTensor.
+///
+/// This Op takes a SparseTensor and is the sparse counterpart to
+/// `tf.reduce_max()`.  In contrast to SparseReduceMax, this Op returns a
+/// SparseTensor.
+///
+/// Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
+/// with length 1.
+///
+/// If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
+/// with a single element is returned.  Additionally, the axes can be negative,
+/// which are interpreted according to the indexing rules in Python.
+///
+/// - Parameters:
+///   - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///     SparseTensor, possibly not in canonical ordering.
+///   - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
+///   - input_shape: 1-D.  Shape of the input SparseTensor.
+///   - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+@inlinable @inline(__always)
+public static func sparseReduceMaxSparse<T: Numeric & TensorFlowScalar>(
+  inputIndices: Tensor<Int64>,
+  inputValues: Tensor<T>,
+  inputShape: Tensor<Int64>,
+  reductionAxes: Tensor<Int32>,
+  keepDims: Bool = false
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, outputShape: Tensor<Int64>) {
+  let op = TFE_Op("SparseReduceMaxSparse")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(inputIndices)
+  let _ = op.addInput(inputValues)
+  let _ = op.addInput(inputShape)
+  let _ = op.addInput(reductionAxes)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes the sum of elements across dimensions of a SparseTensor.
+///
+/// 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
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
+/// with length 1.
+///
+/// If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
+/// with a single element is returned.  Additionally, the axes can be negative,
+/// which are interpreted according to the indexing rules in Python.
+///
+/// - Parameters:
+///   - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///     SparseTensor, possibly not in canonical ordering.
+///   - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
+///   - input_shape: 1-D.  Shape of the input SparseTensor.
+///   - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: `R-K`-D.  The reduced Tensor.
+@inlinable @inline(__always)
+public static func sparseReduceSum<T: Numeric & TensorFlowScalar>(
+  inputIndices: Tensor<Int64>,
+  inputValues: Tensor<T>,
+  inputShape: Tensor<Int64>,
+  reductionAxes: Tensor<Int32>,
+  keepDims: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("SparseReduceSum")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(inputIndices)
+  let _ = op.addInput(inputValues)
+  let _ = op.addInput(inputShape)
+  let _ = op.addInput(reductionAxes)
+  return op.execute(Int(1))
+}
+
+/// Computes the sum of elements across dimensions of a SparseTensor.
+///
+/// This Op takes a SparseTensor and is the sparse counterpart to
+/// `tf.reduce_sum()`.  In contrast to SparseReduceSum, this Op returns a
+/// SparseTensor.
+///
+/// Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
+/// with length 1.
+///
+/// If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
+/// with a single element is returned.  Additionally, the axes can be negative,
+/// which are interpreted according to the indexing rules in Python.
+///
+/// - Parameters:
+///   - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///     SparseTensor, possibly not in canonical ordering.
+///   - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
+///   - input_shape: 1-D.  Shape of the input SparseTensor.
+///   - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+@inlinable @inline(__always)
+public static func sparseReduceSumSparse<T: Numeric & TensorFlowScalar>(
+  inputIndices: Tensor<Int64>,
+  inputValues: Tensor<T>,
+  inputShape: Tensor<Int64>,
+  reductionAxes: Tensor<Int32>,
+  keepDims: Bool = false
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, outputShape: Tensor<Int64>) {
+  let op = TFE_Op("SparseReduceSumSparse")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(inputIndices)
+  let _ = op.addInput(inputValues)
+  let _ = op.addInput(inputShape)
+  let _ = op.addInput(reductionAxes)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Reorders a SparseTensor into the canonical, row-major ordering.
+///
+/// Note that by convention, all sparse ops preserve the canonical ordering along
+/// increasing dimension number. The only time ordering can be violated is during
+/// manual manipulation of the indices and values vectors to add entries.
+///
+/// Reordering does not affect the shape of the SparseTensor.
+///
+/// If the tensor has rank `R` and `N` non-empty values, `input_indices` has
+/// shape `[N, R]`, input_values has length `N`, and input_shape has length `R`.
+///
+/// - Parameters:
+///   - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///     SparseTensor, possibly not in canonical ordering.
+///   - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
+///   - input_shape: 1-D.  Shape of the input SparseTensor.
+///
+/// - Outputs:
+///   - output_indices: 2-D.  `N x R` matrix with the same indices as input_indices, but
+///     in canonical row-major ordering.
+///   - output_values: 1-D.  `N` non-empty values corresponding to `output_indices`.
+@inlinable @inline(__always)
+public static func sparseReorder<T: TensorFlowScalar>(
+  inputIndices: Tensor<Int64>,
+  inputValues: Tensor<T>,
+  inputShape: Tensor<Int64>
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>) {
+  let op = TFE_Op("SparseReorder")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(inputIndices)
+  let _ = op.addInput(inputValues)
+  let _ = op.addInput(inputShape)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Reshapes a SparseTensor to represent values in a new dense shape.
+///
+/// This operation has the same semantics as reshape on the represented dense
+/// tensor.  The `input_indices` are recomputed based on the requested `new_shape`.
+///
+/// If one component of `new_shape` is the special value -1, the size of that
+/// dimension is computed so that the total dense size remains constant.  At
+/// most one component of `new_shape` can be -1.  The number of dense elements
+/// implied by `new_shape` must be the same as the number of dense elements
+/// originally implied by `input_shape`.
+///
+/// Reshaping does not affect the order of values in the SparseTensor.
+///
+/// If the input tensor has rank `R_in` and `N` non-empty values, and `new_shape`
+/// has length `R_out`, then `input_indices` has shape `[N, R_in]`,
+/// `input_shape` has length `R_in`, `output_indices` has shape `[N, R_out]`, and
+/// `output_shape` has length `R_out`.
+///
+/// - Parameters:
+///   - input_indices: 2-D.  `N x R_in` matrix with the indices of non-empty values in a
+///     SparseTensor.
+///   - input_shape: 1-D.  `R_in` vector with the input SparseTensor's dense shape.
+///   - new_shape: 1-D.  `R_out` vector with the requested new dense shape.
+///
+/// - Outputs:
+///   - output_indices: 2-D.  `N x R_out` matrix with the updated indices of non-empty
+///     values in the output SparseTensor.
+///   - output_shape: 1-D.  `R_out` vector with the full dense shape of the output
+///     SparseTensor.  This is the same as `new_shape` but with any -1 dimensions
+///     filled in.
+@inlinable @inline(__always)
+public static func sparseReshape(
+  inputIndices: Tensor<Int64>,
+  inputShape: Tensor<Int64>,
+  newShape: Tensor<Int64>
+) -> (outputIndices: Tensor<Int64>, outputShape: Tensor<Int64>) {
+  let op = TFE_Op("SparseReshape")
+  let _ = op.addInput(inputIndices)
+  let _ = op.addInput(inputShape)
+  let _ = op.addInput(newShape)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Computes the mean along sparse segments of a tensor.
+///
+/// See `tf.sparse.segment_sum` for usage examples.
+///
+/// Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first
+/// dimension, selecting a subset of dimension 0, specified by `indices`.
+///
+/// - Parameters:
+///   - indices: A 1-D tensor. Has same rank as `segment_ids`.
+///   - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///   has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func sparseSegmentMean<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  indices: Tensor<Tidx>,
+  segmentIds: Tensor<Int32>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseSegmentMean")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(segmentIds)
+  return op.execute(Int(1))
+}
+
+/// Computes gradients for SparseSegmentMean.
+///
+/// Returns tensor "output" with same shape as grad, except for dimension 0 whose
+/// value is output_dim0.
+///
+/// - Parameters:
+///   - grad: gradient propagated to the SparseSegmentMean op.
+///   - indices: indices passed to the corresponding SparseSegmentMean op.
+///   - segment_ids: segment_ids passed to the corresponding SparseSegmentMean op.
+///   - output_dim0: dimension 0 of "data" passed to SparseSegmentMean op.
+@inlinable @inline(__always)
+public static func sparseSegmentMeanGrad<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  grad: Tensor<T>,
+  indices: Tensor<Tidx>,
+  segmentIds: Tensor<Int32>,
+  outputDim0: Tensor<Int32>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseSegmentMeanGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(segmentIds)
+  let _ = op.addInput(outputDim0)
+  return op.execute(Int(1))
+}
+
+/// Computes the mean along sparse segments of a tensor.
+///
+/// Like `SparseSegmentMean`, but allows missing ids in `segment_ids`. If an id is
+/// misisng, the `output` tensor at that position will be zeroed.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// - Parameters:
+///   - indices: A 1-D tensor. Has same rank as `segment_ids`.
+///   - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
+///   - num_segments: Should equal the number of distinct segment IDs.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which has size
+///   `num_segments`.
+@inlinable @inline(__always)
+public static func sparseSegmentMeanWithNumSegments<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  indices: Tensor<Tidx>,
+  segmentIds: Tensor<Int32>,
+  numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseSegmentMeanWithNumSegments")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(segmentIds)
+  let _ = op.addInput(numSegments)
+  return op.execute(Int(1))
+}
+
+/// Computes the sum along sparse segments of a tensor divided by the sqrt of N.
+///
+/// N is the size of the segment being reduced.
+///
+/// See `tf.sparse.segment_sum` for usage examples.
+///
+///
+/// - Parameters:
+///   - indices: A 1-D tensor. Has same rank as `segment_ids`.
+///   - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///   has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func sparseSegmentSqrtN<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  indices: Tensor<Tidx>,
+  segmentIds: Tensor<Int32>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseSegmentSqrtN")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(segmentIds)
+  return op.execute(Int(1))
+}
+
+/// Computes gradients for SparseSegmentSqrtN.
+///
+/// Returns tensor "output" with same shape as grad, except for dimension 0 whose
+/// value is output_dim0.
+///
+/// - Parameters:
+///   - grad: gradient propagated to the SparseSegmentSqrtN op.
+///   - indices: indices passed to the corresponding SparseSegmentSqrtN op.
+///   - segment_ids: segment_ids passed to the corresponding SparseSegmentSqrtN op.
+///   - output_dim0: dimension 0 of "data" passed to SparseSegmentSqrtN op.
+@inlinable @inline(__always)
+public static func sparseSegmentSqrtNGrad<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  grad: Tensor<T>,
+  indices: Tensor<Tidx>,
+  segmentIds: Tensor<Int32>,
+  outputDim0: Tensor<Int32>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseSegmentSqrtNGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(segmentIds)
+  let _ = op.addInput(outputDim0)
+  return op.execute(Int(1))
+}
+
+/// Computes the sum along sparse segments of a tensor divided by the sqrt of N.
+///
+/// N is the size of the segment being reduced.
+///
+/// Like `SparseSegmentSqrtN`, but allows missing ids in `segment_ids`. If an id is
+/// misisng, the `output` tensor at that position will be zeroed.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// - Parameters:
+///   - indices: A 1-D tensor. Has same rank as `segment_ids`.
+///   - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
+///   - num_segments: Should equal the number of distinct segment IDs.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///   has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func sparseSegmentSqrtNWithNumSegments<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  indices: Tensor<Tidx>,
+  segmentIds: Tensor<Int32>,
+  numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseSegmentSqrtNWithNumSegments")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(segmentIds)
+  let _ = op.addInput(numSegments)
+  return op.execute(Int(1))
+}
+
+/// Computes the sum along sparse segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first
+/// dimension, selecting a subset of dimension 0, specified by `indices`.
+///
+/// For example:
+///
+/// ```python
+/// c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
+///
+/// # Select two rows, one segment.
+/// tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))
+/// # => [[0 0 0 0]]
+///
+/// # Select two rows, two segment.
+/// tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))
+/// # => [[ 1  2  3  4]
+/// #     [-1 -2 -3 -4]]
+///
+/// # Select all rows, two segments.
+/// tf.sparse_segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))
+/// # => [[0 0 0 0]
+/// #     [5 6 7 8]]
+///
+/// # Which is equivalent to:
+/// tf.segment_sum(c, tf.constant([0, 0, 1]))
+/// ```
+///
+/// - Parameters:
+///   - indices: A 1-D tensor. Has same rank as `segment_ids`.
+///   - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///   has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func sparseSegmentSum<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  indices: Tensor<Tidx>,
+  segmentIds: Tensor<Int32>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseSegmentSum")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(segmentIds)
+  return op.execute(Int(1))
+}
+
+/// Computes the sum along sparse segments of a tensor.
+///
+/// Like `SparseSegmentSum`, but allows missing ids in `segment_ids`. If an id is
+/// misisng, the `output` tensor at that position will be zeroed.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/sparse#Segmentation)
+/// for an explanation of segments.
+///
+/// For example:
+///
+/// ```python
+/// c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
+///
+/// tf.sparse_segment_sum_with_num_segments(
+///     c, tf.constant([0, 1]), tf.constant([0, 0]), num_segments=3)
+/// # => [[0 0 0 0]
+/// #     [0 0 0 0]
+/// #     [0 0 0 0]]
+///
+/// tf.sparse_segment_sum_with_num_segments(c,
+///                                         tf.constant([0, 1]),
+///                                         tf.constant([0, 2],
+///                                         num_segments=4))
+/// # => [[ 1  2  3  4]
+/// #     [ 0  0  0  0]
+/// #     [-1 -2 -3 -4]
+/// #     [ 0  0  0  0]]
+/// ```
+///
+/// - Parameters:
+///   - indices: A 1-D tensor. Has same rank as `segment_ids`.
+///   - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
+///   - num_segments: Should equal the number of distinct segment IDs.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///   has size `num_segments`.
+@inlinable @inline(__always)
+public static func sparseSegmentSumWithNumSegments<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  indices: Tensor<Tidx>,
+  segmentIds: Tensor<Int32>,
+  numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseSegmentSumWithNumSegments")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(segmentIds)
+  let _ = op.addInput(numSegments)
+  return op.execute(Int(1))
+}
+
+/// Slice a `SparseTensor` based on the `start` and `size`.
+///
+/// For example, if the input is
+///
+///     input_tensor = shape = [2, 7]
+///     [    a   d e  ]
+///     [b c          ]
+///
+/// Graphically the output tensors are:
+///
+///     sparse_slice([0, 0], [2, 4]) = shape = [2, 4]
+///     [    a  ]
+///     [b c    ]
+///
+///     sparse_slice([0, 4], [2, 3]) = shape = [2, 3]
+///     [ d e  ]
+///     [      ]
+///
+/// - Parameters:
+///   - indices: 2-D tensor represents the indices of the sparse tensor.
+///   - values: 1-D tensor represents the values of the sparse tensor.
+///   - shape: 1-D. tensor represents the shape of the sparse tensor.
+///   - start: 1-D. tensor represents the start of the slice.
+///   - size: 1-D. tensor represents the size of the slice.
+///     output indices: A list of 1-D tensors represents the indices of the output
+///     sparse tensors.
+///
+/// - Outputs:
+///   - output_values: A list of 1-D tensors represents the values of the output sparse
+///     tensors.
+///   - output_shape: A list of 1-D tensors represents the shape of the output sparse
+///     tensors.
+@inlinable @inline(__always)
+public static func sparseSlice<T: TensorFlowScalar>(
+  indices: Tensor<Int64>,
+  _ values: Tensor<T>,
+  shape: Tensor<Int64>,
+  start: Tensor<Int64>,
+  size: Tensor<Int64>
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, outputShape: Tensor<Int64>) {
+  let op = TFE_Op("SparseSlice")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(values)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(start)
+  let _ = op.addInput(size)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// The gradient operator for the SparseSlice op.
+///
+/// This op takes in the upstream gradient w.r.t. non-empty values of
+/// the sliced `SparseTensor`, and outputs the gradients w.r.t.
+/// the non-empty values of input `SparseTensor`.
+///
+/// - Parameters:
+///   - backprop_val_grad: 1-D. The gradient with respect to
+///     the non-empty values of the sliced `SparseTensor`.
+///   - input_indices: 2-D.  The `indices` of the input `SparseTensor`.
+///   - input_start: 1-D. tensor represents the start of the slice.
+///   - output_indices: 2-D.  The `indices` of the sliced `SparseTensor`.
+///
+/// - Output val_grad: 1-D. The gradient with respect to the non-empty values of input `SparseTensor`.
+@inlinable @inline(__always)
+public static func sparseSliceGrad<T: Numeric & TensorFlowScalar>(
+  backpropValGrad: Tensor<T>,
+  inputIndices: Tensor<Int64>,
+  inputStart: Tensor<Int64>,
+  outputIndices: Tensor<Int64>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseSliceGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(backpropValGrad)
+  let _ = op.addInput(inputIndices)
+  let _ = op.addInput(inputStart)
+  let _ = op.addInput(outputIndices)
+  return op.execute(Int(1))
+}
+
+/// Applies softmax to a batched N-D `SparseTensor`.
+///
+/// The inputs represent an N-D SparseTensor  with logical shape `[..., B, C]`
+/// (where `N >= 2`), and with indices sorted in the canonical lexicographic order.
+///
+/// This op is equivalent to applying the normal `tf.nn.softmax()` to each innermost
+/// logical submatrix with shape `[B, C]`, but with the catch that *the implicitly
+/// zero elements do not participate*.  Specifically, the algorithm is equivalent
+/// to the following:
+///
+///   (1) Applies `tf.nn.softmax()` to a densified view of each innermost submatrix
+///       with shape `[B, C]`, along the size-C dimension;
+///   (2) Masks out the original implicitly-zero locations;
+///   (3) Renormalizes the remaining elements.
+///
+/// Hence, the `SparseTensor` result has exactly the same non-zero indices and
+/// shape.
+///
+/// - Parameters:
+///   - sp_indices: 2-D.  `NNZ x R` matrix with the indices of non-empty values in a
+///     SparseTensor, in canonical ordering.
+///   - sp_values: 1-D.  `NNZ` non-empty values corresponding to `sp_indices`.
+///   - sp_shape: 1-D.  Shape of the input SparseTensor.
+///
+/// - Output output: 1-D.  The `NNZ` values for the result `SparseTensor`.
+@inlinable @inline(__always)
+public static func sparseSoftmax<T: FloatingPoint & TensorFlowScalar>(
+  spIndices: Tensor<Int64>,
+  spValues: Tensor<T>,
+  spShape: Tensor<Int64>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseSoftmax")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(spIndices)
+  let _ = op.addInput(spValues)
+  let _ = op.addInput(spShape)
+  return op.execute(Int(1))
+}
+
+/// Computes softmax cross entropy cost and gradients to backpropagate.
+///
+/// Unlike `SoftmaxCrossEntropyWithLogits`, this operation does not accept
+/// a matrix of label probabilities, but rather a single label per row
+/// of features.  This label is considered to have probability 1.0 for the
+/// given row.
+///
+/// Inputs are the logits, not probabilities.
+///
+/// - Parameters:
+///   - features: batch_size x num_classes matrix
+///   - labels: batch_size vector with values in [0, num_classes).
+///     This is the label for the given minibatch entry.
+///
+/// - Outputs:
+///   - loss: Per example loss (batch_size vector).
+///   - backprop: backpropagated gradients (batch_size x num_classes matrix).
+@inlinable @inline(__always)
+public static func sparseSoftmaxCrossEntropyWithLogits<
+    T: FloatingPoint & TensorFlowScalar,
+    Tlabels: BinaryInteger & TensorFlowScalar
+>(
+  features: Tensor<T>,
+  labels: Tensor<Tlabels>
+) -> (loss: Tensor<T>, backprop: Tensor<T>) {
+  let op = TFE_Op("SparseSoftmaxCrossEntropyWithLogits")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tlabels", Tlabels.tensorFlowDataType)
+  let _ = op.addInput(features)
+  let _ = op.addInput(labels)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Returns the element-wise max of two SparseTensors.
+///
+/// Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
+///
+/// - Parameters:
+///   - 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.
+///
+/// - Outputs:
+///   - output_indices: 2-D.  The indices of the output SparseTensor.
+///   - output_values: 1-D.  The values of the output SparseTensor.
+@inlinable @inline(__always)
+public static func sparseSparseMaximum<T: Numeric & TensorFlowScalar>(
+  aIndices: Tensor<Int64>,
+  aValues: Tensor<T>,
+  aShape: Tensor<Int64>,
+  bIndices: Tensor<Int64>,
+  bValues: Tensor<T>,
+  bShape: Tensor<Int64>
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>) {
+  let op = TFE_Op("SparseSparseMaximum")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(aIndices)
+  let _ = op.addInput(aValues)
+  let _ = op.addInput(aShape)
+  let _ = op.addInput(bIndices)
+  let _ = op.addInput(bValues)
+  let _ = op.addInput(bShape)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Returns the element-wise min of two SparseTensors.
+///
+/// Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
+///
+/// - Parameters:
+///   - 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.
+///
+/// - Outputs:
+///   - output_indices: 2-D.  The indices of the output SparseTensor.
+///   - output_values: 1-D.  The values of the output SparseTensor.
+@inlinable @inline(__always)
+public static func sparseSparseMinimum<T: Numeric & TensorFlowScalar>(
+  aIndices: Tensor<Int64>,
+  aValues: Tensor<T>,
+  aShape: Tensor<Int64>,
+  bIndices: Tensor<Int64>,
+  bValues: Tensor<T>,
+  bShape: Tensor<Int64>
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>) {
+  let op = TFE_Op("SparseSparseMinimum")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(aIndices)
+  let _ = op.addInput(aValues)
+  let _ = op.addInput(aShape)
+  let _ = op.addInput(bIndices)
+  let _ = op.addInput(bValues)
+  let _ = op.addInput(bShape)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Split a `SparseTensor` into `num_split` tensors along one dimension.
+///
+/// If the `shape[split_dim]` is not an integer multiple of `num_split`. Slices
+/// `[0 : shape[split_dim] % num_split]` gets one extra dimension.
+/// For example, if `split_dim = 1` and `num_split = 2` and the input is
+///
+///     input_tensor = shape = [2, 7]
+///     [    a   d e  ]
+///     [b c          ]
+///
+/// Graphically the output tensors are:
+///
+///     output_tensor[0] = shape = [2, 4]
+///     [    a  ]
+///     [b c    ]
+///
+///     output_tensor[1] = shape = [2, 3]
+///     [ d e  ]
+///     [      ]
+///
+/// - Parameters:
+///   - split_dim: 0-D.  The dimension along which to split.  Must be in the range
+///     `[0, rank(shape))`.
+///   - indices: 2-D tensor represents the indices of the sparse tensor.
+///   - values: 1-D tensor represents the values of the sparse tensor.
+///   - shape: 1-D. tensor represents the shape of the sparse tensor.
+///     output indices: A list of 1-D tensors represents the indices of the output
+///     sparse tensors.
+///
+/// - Attr num_split: The number of ways to split.
+///
+/// - Outputs:
+///   - output_values: A list of 1-D tensors represents the values of the output sparse
+///     tensors.
+///   - output_shape: A list of 1-D tensors represents the shape of the output sparse
+///     tensors.
+@inlinable @inline(__always)
+public static func sparseSplit<T: TensorFlowScalar>(
+  splitDim: Tensor<Int64>,
+  indices: Tensor<Int64>,
+  _ values: Tensor<T>,
+  shape: Tensor<Int64>,
+  numSplit: Int64
+) -> (outputIndices: [Tensor<Int64>], outputValues: [Tensor<T>], outputShape: [Tensor<Int64>]) {
+  let op = TFE_Op("SparseSplit")
+  op.setAttr("num_split", numSplit)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(splitDim)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(values)
+  let _ = op.addInput(shape)
+  return op.execute(Int(numSplit), Int(numSplit), Int(numSplit))
+}
+
+/// Adds up a `SparseTensor` and a dense `Tensor`, producing a dense `Tensor`.
+///
+/// This Op does not require `a_indices` be sorted in standard lexicographic order.
+///
+/// - Parameters:
+///   - a_indices: 2-D.  The `indices` of the `SparseTensor`, with shape `[nnz, ndims]`.
+///   - a_values: 1-D.  The `values` of the `SparseTensor`, with shape `[nnz]`.
+///   - a_shape: 1-D.  The `shape` of the `SparseTensor`, with shape `[ndims]`.
+///   - b: `ndims`-D Tensor.  With shape `a_shape`.
+@inlinable @inline(__always)
+public static func sparseTensorDenseAdd<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  aIndices: Tensor<Tindices>,
+  aValues: Tensor<T>,
+  aShape: Tensor<Tindices>,
+  _ b: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("SparseTensorDenseAdd")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(aIndices)
+  let _ = op.addInput(aValues)
+  let _ = op.addInput(aShape)
+  let _ = op.addInput(b)
+  return op.execute(Int(1))
+}
+
+/// Multiply SparseTensor (of rank 2) "A" by dense matrix "B".
+///
+/// No validity checking is performed on the indices of A.  However, the following
+/// input format is recommended for optimal behavior:
+///
+/// if adjoint_a == false:
+///   A should be sorted in lexicographically increasing order.  Use SparseReorder
+///   if you're not sure.
+/// if adjoint_a == true:
+///   A should be sorted in order of increasing dimension 1 (i.e., "column major"
+///   order instead of "row major" order).
+///
+/// - Parameters:
+///   - a_indices: 2-D.  The `indices` of the `SparseTensor`, size `[nnz, 2]` Matrix.
+///   - a_values: 1-D.  The `values` of the `SparseTensor`, size `[nnz]` Vector.
+///   - a_shape: 1-D.  The `shape` of the `SparseTensor`, size `[2]` Vector.
+///   - b: 2-D.  A dense Matrix.
+///
+/// - Attrs:
+///   - adjoint_a: Use the adjoint of A in the matrix multiply.  If A is complex, this
+///     is transpose(conj(A)).  Otherwise it's transpose(A).
+///   - adjoint_b: Use the adjoint of B in the matrix multiply.  If B is complex, this
+///     is transpose(conj(B)).  Otherwise it's transpose(B).
+@inlinable @inline(__always)
+public static func sparseTensorDenseMatMul<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  aIndices: Tensor<Tindices>,
+  aValues: Tensor<T>,
+  aShape: Tensor<Int64>,
+  _ b: Tensor<T>,
+  adjointA: Bool = false,
+  adjointB: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("SparseTensorDenseMatMul")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("adjoint_a", adjointA)
+  op.setAttr("adjoint_b", adjointB)
+  let _ = op.addInput(aIndices)
+  let _ = op.addInput(aValues)
+  let _ = op.addInput(aShape)
+  let _ = op.addInput(b)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that splits a SparseTensor into elements row-wise.
+@inlinable @inline(__always)
+public static func sparseTensorSliceDataset<Tvalues: TensorFlowScalar>(
+  indices: Tensor<Int64>,
+  _ values: Tensor<Tvalues>,
+  denseShape: Tensor<Int64>
+) -> VariantHandle {
+  let op = TFE_Op("SparseTensorSliceDataset")
+  op.setAttr("Tvalues", Tvalues.tensorFlowDataType)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(values)
+  let _ = op.addInput(denseShape)
+  return op.execute(Int(1))
+}
+
+/// Converts a sparse representation into a dense tensor.
+///
+/// Builds an array `dense` with shape `output_shape` such that
+///
+/// ```
+/// # If sparse_indices is scalar
+/// dense[i] = (i == sparse_indices ? sparse_values : default_value)
+///
+/// # If sparse_indices is a vector, then for each i
+/// dense[sparse_indices[i]] = sparse_values[i]
+///
+/// # If sparse_indices is an n by d matrix, then for each i in [0, n)
+/// dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i]
+/// ```
+///
+/// All other values in `dense` are set to `default_value`.  If `sparse_values` is a
+/// scalar, all sparse indices are set to this single value.
+///
+/// Indices should be sorted in lexicographic order, and indices must not
+/// contain any repeats. If `validate_indices` is true, these properties
+/// are checked during execution.
+///
+/// - Parameters:
+///   - sparse_indices: 0-D, 1-D, or 2-D.  `sparse_indices[i]` contains the complete
+///     index where `sparse_values[i]` will be placed.
+///   - output_shape: 1-D.  Shape of the dense output tensor.
+///   - sparse_values: 1-D.  Values corresponding to each row of `sparse_indices`,
+///     or a scalar value to be used for all sparse indices.
+///   - default_value: Scalar value to set for indices not specified in
+///     `sparse_indices`.
+///
+/// - Attr validate_indices: If true, indices are checked to make sure they are sorted in
+///   lexicographic order and that there are no repeats.
+///
+/// - Output dense: Dense output tensor of shape `output_shape`.
+@inlinable @inline(__always)
+public static func sparseToDense<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  sparseIndices: Tensor<Tindices>,
+  outputShape: Tensor<Tindices>,
+  sparseValues: Tensor<T>,
+  defaultValue: Tensor<T>,
+  validateIndices: Bool = true
+) -> Tensor<T> {
+  let op = TFE_Op("SparseToDense")
+  op.setAttr("validate_indices", validateIndices)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(sparseIndices)
+  let _ = op.addInput(outputShape)
+  let _ = op.addInput(sparseValues)
+  let _ = op.addInput(defaultValue)
+  return op.execute(Int(1))
+}
+
+/// Applies set operation along last dimension of 2 `SparseTensor` inputs.
+///
+/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+///
+/// If `validate_indices` is `True`, `SparseToSparseSetOperation` validates the
+/// order and range of `set1` and `set2` indices.
+///
+/// Input `set1` is a `SparseTensor` represented by `set1_indices`, `set1_values`,
+/// and `set1_shape`. For `set1` ranked `n`, 1st `n-1` dimensions must be the same
+/// as `set2`. Dimension `n` contains values in a set, duplicates are allowed but
+/// ignored.
+///
+/// Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
+/// and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
+/// as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
+/// ignored.
+///
+/// If `validate_indices` is `True`, this op validates the order and range of `set1`
+/// and `set2` indices.
+///
+/// Output `result` is a `SparseTensor` represented by `result_indices`,
+/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+/// dimension contains the result of `set_operation` applied to the corresponding
+/// `[0...n-1]` dimension of `set`.
+///
+/// - Parameters:
+///   - set1_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+///     order.
+///   - set1_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+///     order.
+///   - set1_shape: 1D `Tensor`, shape of a `SparseTensor`. `set1_shape[0...n-1]` must
+///     be the same as `set2_shape[0...n-1]`, `set1_shape[n]` is the
+///     max set size across `0...n-1` dimensions.
+///   - set2_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+///     order.
+///   - set2_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+///     order.
+///   - set2_shape: 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
+///     be the same as `set1_shape[0...n-1]`, `set2_shape[n]` is the
+///     max set size across `0...n-1` dimensions.
+///
+/// - Outputs:
+///   - result_indices: 2D indices of a `SparseTensor`.
+///   - result_values: 1D values of a `SparseTensor`.
+///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+///     is the max result set size across all `0...n-1` dimensions.
+@inlinable @inline(__always)
+public static func sparseToSparseSetOperation<T: BinaryInteger & TensorFlowScalar>(
+  set1Indices: Tensor<Int64>,
+  set1Values: Tensor<T>,
+  set1Shape: Tensor<Int64>,
+  set2Indices: Tensor<Int64>,
+  set2Values: Tensor<T>,
+  set2Shape: Tensor<Int64>,
+  setOperation: String,
+  validateIndices: Bool = true
+) -> (resultIndices: Tensor<Int64>, resultValues: Tensor<T>, resultShape: Tensor<Int64>) {
+  let op = TFE_Op("SparseToSparseSetOperation")
+  op.setAttr("set_operation", setOperation)
+  op.setAttr("validate_indices", validateIndices)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(set1Indices)
+  let _ = op.addInput(set1Values)
+  let _ = op.addInput(set1Shape)
+  let _ = op.addInput(set2Indices)
+  let _ = op.addInput(set2Values)
+  let _ = op.addInput(set2Shape)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Applies set operation along last dimension of 2 `SparseTensor` inputs.
+///
+/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+///
+/// If `validate_indices` is `True`, `SparseToSparseSetOperation` validates the
+/// order and range of `set1` and `set2` indices.
+///
+/// Input `set1` is a `SparseTensor` represented by `set1_indices`, `set1_values`,
+/// and `set1_shape`. For `set1` ranked `n`, 1st `n-1` dimensions must be the same
+/// as `set2`. Dimension `n` contains values in a set, duplicates are allowed but
+/// ignored.
+///
+/// Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
+/// and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
+/// as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
+/// ignored.
+///
+/// If `validate_indices` is `True`, this op validates the order and range of `set1`
+/// and `set2` indices.
+///
+/// Output `result` is a `SparseTensor` represented by `result_indices`,
+/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+/// dimension contains the result of `set_operation` applied to the corresponding
+/// `[0...n-1]` dimension of `set`.
+///
+/// - Parameters:
+///   - set1_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+///     order.
+///   - set1_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+///     order.
+///   - set1_shape: 1D `Tensor`, shape of a `SparseTensor`. `set1_shape[0...n-1]` must
+///     be the same as `set2_shape[0...n-1]`, `set1_shape[n]` is the
+///     max set size across `0...n-1` dimensions.
+///   - set2_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+///     order.
+///   - set2_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+///     order.
+///   - set2_shape: 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
+///     be the same as `set1_shape[0...n-1]`, `set2_shape[n]` is the
+///     max set size across `0...n-1` dimensions.
+///
+/// - Outputs:
+///   - result_indices: 2D indices of a `SparseTensor`.
+///   - result_values: 1D values of a `SparseTensor`.
+///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+///     is the max result set size across all `0...n-1` dimensions.
+@inlinable @inline(__always)
+public static func sparseToSparseSetOperation(
+  set1Indices: Tensor<Int64>,
+  set1Values: StringTensor,
+  set1Shape: Tensor<Int64>,
+  set2Indices: Tensor<Int64>,
+  set2Values: StringTensor,
+  set2Shape: Tensor<Int64>,
+  setOperation: String,
+  validateIndices: Bool = true
+) -> (resultIndices: Tensor<Int64>, resultValues: StringTensor, resultShape: Tensor<Int64>) {
+  let op = TFE_Op("SparseToSparseSetOperation")
+  op.setAttr("set_operation", setOperation)
+  op.setAttr("validate_indices", validateIndices)
+  op.setAttr("T", TensorDataType(TF_STRING))
+  let _ = op.addInput(set1Indices)
+  let _ = op.addInput(set1Values)
+  let _ = op.addInput(set1Shape)
+  let _ = op.addInput(set2Indices)
+  let _ = op.addInput(set2Values)
+  let _ = op.addInput(set2Shape)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Splits a tensor into `num_split` tensors along one dimension.
+///
+/// - Parameters:
+///   - split_dim: 0-D.  The dimension along which to split.  Must be in the range
+///     `[-rank(value), rank(value))`.
+///   - value: The tensor to split.
+///
+/// - Attr num_split: The number of ways to split.  Must evenly divide
+///   `value.shape[split_dim]`.
+///
+/// - Output output: They are identically shaped tensors, whose shape matches that of `value`
+///   except along `axis`, where their sizes are
+///   `values.shape[split_dim] / num_split`.
+@inlinable @inline(__always)
+public static func split<T: TensorFlowScalar>(
+  splitDim: Tensor<Int32>,
+  value: Tensor<T>,
+  numSplit: Int64
+) -> [Tensor<T>] {
+  let op = TFE_Op("Split")
+  op.setAttr("num_split", numSplit)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(splitDim)
+  let _ = op.addInput(value)
+  return op.execute(Int(numSplit))
+}
+
+/// Splits a tensor into `num_split` tensors along one dimension.
+///
+/// - Parameters:
+///   - value: The tensor to split.
+///   - size_splits: list containing the sizes of each output tensor along the split
+///     dimension. Must sum to the dimension of value along split_dim.
+///     Can contain one -1 indicating that dimension is to be inferred.
+///   - split_dim: 0-D.  The dimension along which to split.  Must be in the range
+///     `[-rank(value), rank(value))`.
+///
+/// - Output output: Tensors whose shape matches that of `value`
+///   except along `axis`, where their sizes are
+///   `size_splits[i]`.
+@inlinable @inline(__always)
+public static func splitV<
+    T: TensorFlowScalar,
+    Tlen: BinaryInteger & TensorFlowScalar
+>(
+  value: Tensor<T>,
+  sizeSplits: Tensor<Tlen>,
+  splitDim: Tensor<Int32>,
+  numSplit: Int64
+) -> [Tensor<T>] {
+  let op = TFE_Op("SplitV")
+  op.setAttr("num_split", numSplit)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tlen", Tlen.tensorFlowDataType)
+  let _ = op.addInput(value)
+  let _ = op.addInput(sizeSplits)
+  let _ = op.addInput(splitDim)
+  return op.execute(Int(numSplit))
+}
+
+/// Computes square root of x element-wise.
+///
+/// I.e., \\(y = \sqrt{x} = x^{1/2}\\).
+@inlinable @inline(__always)
+public static func sqrt<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Sqrt")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient for the sqrt of `x` wrt its input.
+///
+/// Specifically, `grad = dy * 0.5 / y`, where `y = sqrt(x)`, and `dy`
+/// is the corresponding input gradient.
+@inlinable @inline(__always)
+public static func sqrtGrad<T: FloatingPoint & TensorFlowScalar>(
+  _ y: Tensor<T>,
+  dy: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("SqrtGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(y)
+  let _ = op.addInput(dy)
+  return op.execute(Int(1))
+}
+
+/// Computes square of x element-wise.
+///
+/// I.e., \\(y = x * x = x^2\\).
+@inlinable @inline(__always)
+public static func square<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Square")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Returns (x - y)(x - y) element-wise.
+///
+/// *NOTE*: `SquaredDifference` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func squaredDifference<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("SquaredDifference")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Removes dimensions of size 1 from the shape of a tensor.
+///
+/// Given a tensor `input`, this operation returns a tensor of the same type with
+/// all dimensions of size 1 removed. If you don't want to remove all size 1
+/// dimensions, you can remove specific size 1 dimensions by specifying
+/// `axis`.
+///
+/// For example:
+///
+/// ```
+/// # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
+/// shape(squeeze(t)) ==> [2, 3]
+/// ```
+///
+/// Or, to remove specific size 1 dimensions:
+///
+/// ```
+/// # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
+/// shape(squeeze(t, [2, 4])) ==> [1, 2, 3, 1]
+/// ```
+///
+/// - Parameter input: The `input` to squeeze.
+///
+/// - Attr squeeze_dims: If specified, only squeezes the dimensions listed. The dimension
+///   index starts at 0. It is an error to squeeze a dimension that is not 1. Must
+///   be in the range `[-rank(input), rank(input))`.
+///
+/// - Output output: Contains the same data as `input`, but has one or more dimensions of
+///   size 1 removed.
+@inlinable @inline(__always)
+public static func squeeze<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  squeezeDims: [Int32]
+) -> Tensor<T> {
+  let op = TFE_Op("Squeeze")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("squeeze_dims", squeezeDims)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Delete the stack from its resource container.
+///
+/// - Parameter handle: The handle to a stack.
+@inlinable @inline(__always)
+public static func stackCloseV2(
+  handle: ResourceHandle
+) {
+  let op = TFE_Op("StackCloseV2")
+  let _ = op.addInput(handle)
+  op.execute()
+}
+
+/// Pop the element at the top of the stack.
+///
+/// - Parameter handle: The handle to a stack.
+///
+/// - Attr elem_type: The type of the elem that is popped.
+///
+/// - Output elem: The tensor that is popped from the top of the stack.
+@inlinable @inline(__always)
+public static func stackPopV2<ElemType: TensorFlowScalar>(
+  handle: ResourceHandle
+) -> Tensor<ElemType> {
+  let op = TFE_Op("StackPopV2")
+  op.setAttr("elem_type", ElemType.tensorFlowDataType)
+  let _ = op.addInput(handle)
+  return op.execute(Int(1))
+}
+
+/// Push an element onto the stack.
+///
+/// - Parameters:
+///   - handle: The handle to a stack.
+///   - elem: The tensor to be pushed onto the stack.
+///
+/// - Attr swap_memory: Swap `elem` to CPU. Default to false.
+///
+/// - Output output: The same tensor as the input 'elem'.
+@inlinable @inline(__always)
+public static func stackPushV2<T: TensorFlowScalar>(
+  handle: ResourceHandle,
+  elem: Tensor<T>,
+  swapMemory: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("StackPushV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("swap_memory", swapMemory)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(elem)
+  return op.execute(Int(1))
+}
+
+/// A stack that produces elements in first-in last-out order.
+///
+/// - Parameter max_size: The maximum size of the stack if non-negative. If negative, the stack
+///   size is unlimited.
+///
+/// - Attrs:
+///   - elem_type: The type of the elements on the stack.
+///   - stack_name: Overrides the name used for the temporary stack resource. Default
+///     value is the name of the 'Stack' op (which is guaranteed unique).
+///
+/// - Output handle: The handle to the stack.
+@inlinable @inline(__always)
+public static func stackV2(
+  maxSize: Tensor<Int32>,
+  elemType: TensorDataType,
+  stackName: String
+) -> ResourceHandle {
+  let op = TFE_Op("StackV2")
+  op.setAttr("elem_type", elemType)
+  op.setAttr("stack_name", stackName)
+  let _ = op.addInput(maxSize)
+  return op.execute(Int(1))
+}
+
+/// Stage values similar to a lightweight Enqueue.
+///
+/// The basic functionality of this Op is similar to a queue with many
+/// fewer capabilities and options.  This Op is optimized for performance.
+///
+/// - Parameter values: a list of tensors
+///   dtypes A list of data types that inserted values should adhere to.
+///
+/// - Attrs:
+///   - capacity: Maximum number of elements in the Staging Area. If > 0, inserts
+///     on the container will block when the capacity is reached.
+///   - memory_limit: The maximum number of bytes allowed for Tensors in the Staging Area.
+///     If > 0, inserts will block until sufficient space is available.
+///   - container: If non-empty, this queue is placed in the given container. Otherwise,
+///     a default container is used.
+///   - shared_name: It is necessary to match this name to the matching Unstage Op.
+@inlinable @inline(__always)
+public static func stage<Dtypes: TensorArrayProtocol>(
+  _ values: Dtypes,
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  container: String,
+  sharedName: String
+) {
+  let op = TFE_Op("Stage")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", values._typeList)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInputList(values)
+  op.execute()
+}
+
+/// Op removes all elements in the underlying container.
+@inlinable @inline(__always)
+public static func stageClear(
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  dtypes: [TensorDataType],
+  container: String,
+  sharedName: String
+) {
+  let op = TFE_Op("StageClear")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", dtypes)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.execute()
+}
+
+/// Op peeks at the values at the specified index.  If the
+///
+/// underlying container does not contain sufficient elements
+/// this op will block until it does.   This Op is optimized for
+/// performance.
+@inlinable @inline(__always)
+public static func stagePeek<Dtypes: TensorGroup>(
+  index: Tensor<Int32>,
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  container: String,
+  sharedName: String
+) -> Dtypes {
+  let op = TFE_Op("StagePeek")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", Dtypes._typeList)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(index)
+  return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// Op returns the number of elements in the underlying container.
+@inlinable @inline(__always)
+public static func stageSize(
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  dtypes: [TensorDataType],
+  container: String,
+  sharedName: String
+) -> Tensor<Int32> {
+  let op = TFE_Op("StageSize")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", dtypes)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// returns `f(inputs)`, where `f`'s body is placed and partitioned.
+///
+/// - Parameter args: A list of input tensors.
+///
+/// - Attrs:
+///   - Tin: A list of input types.
+///   - Tout: A list of output types.
+///   - f:       A function that takes 'args', a list of tensors, and returns 'output',
+///           another list of tensors. Input and output types are specified by 'Tin'
+///           and 'Tout'. The function body of f will be placed and partitioned across
+///           devices, setting this op apart from the regular Call op. This op is
+///           stateful.
+///
+/// - Output output: A list of return values.
+@inlinable @inline(__always)
+public static func statefulPartitionedCall<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    FIn: TensorGroup,
+    FOut: TensorGroup
+>(
+  args: Tin,
+  f: (FIn) -> FOut,
+  config: String,
+  configProto: String,
+  executorType: String
+) -> Tout {
+  let op = TFE_Op("StatefulPartitionedCall")
+  op.setAttr("Tin", args._typeList)
+  op.setAttr("Tout", Tout._typeList)
+  op.setAttr("f", f)
+  op.setAttr("config", config)
+  op.setAttr("config_proto", configProto)
+  op.setAttr("executor_type", executorType)
+  let _ = op.addInputList(args)
+  return op.execute(Int(Tout._typeList.count))
+}
+
+@inlinable @inline(__always)
+public static func statefulRandomBinomial<
+    S: BinaryInteger & TensorFlowScalar,
+    T: Numeric & TensorFlowScalar,
+    Dtype: Numeric & TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  algorithm: Tensor<Int64>,
+  shape: Tensor<S>,
+  counts: Tensor<T>,
+  probs: Tensor<T>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("StatefulRandomBinomial")
+  op.setAttr("S", S.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(algorithm)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(counts)
+  let _ = op.addInput(probs)
+  return op.execute(Int(1))
+}
+
+/// Outputs random values from a normal distribution. This op is deprecated in favor of op 'StatefulStandardNormalV2'
+///
+/// The generated values will have mean 0 and standard deviation 1.
+///
+/// - Parameters:
+///   - resource: The handle of the resource variable that stores the state of the RNG.
+///   - shape: The shape of the output tensor.
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: A tensor of the specified shape filled with random normal values.
+@inlinable @inline(__always)
+public static func statefulStandardNormal<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  shape: Tensor<ShapeDtype>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("StatefulStandardNormal")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Outputs random values from a normal distribution.
+///
+/// The generated values will have mean 0 and standard deviation 1.
+///
+/// - Parameters:
+///   - resource: The handle of the resource variable that stores the state of the RNG.
+///   - algorithm: The RNG algorithm.
+///   - shape: The shape of the output tensor.
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: A tensor of the specified shape filled with random normal values.
+@inlinable @inline(__always)
+public static func statefulStandardNormalV2<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  algorithm: Tensor<Int64>,
+  shape: Tensor<ShapeDtype>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("StatefulStandardNormalV2")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(algorithm)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Outputs random values from a truncated normal distribution.
+///
+/// The generated values follow a normal distribution with mean 0 and standard
+/// deviation 1, except that values whose magnitude is more than 2 standard
+/// deviations from the mean are dropped and re-picked.
+///
+/// - Parameters:
+///   - resource: The handle of the resource variable that stores the state of the RNG.
+///   - algorithm: The RNG algorithm.
+///   - shape: The shape of the output tensor.
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statefulTruncatedNormal<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  algorithm: Tensor<Int64>,
+  shape: Tensor<ShapeDtype>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("StatefulTruncatedNormal")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(algorithm)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Outputs random values from a uniform distribution.
+///
+/// The generated values follow a uniform distribution in the range `[0, 1)`. The
+/// lower bound 0 is included in the range, while the upper bound 1 is excluded.
+///
+/// - Parameters:
+///   - resource: The handle of the resource variable that stores the state of the RNG.
+///   - algorithm: The RNG algorithm.
+///   - shape: The shape of the output tensor.
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statefulUniform<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  algorithm: Tensor<Int64>,
+  shape: Tensor<ShapeDtype>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("StatefulUniform")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(algorithm)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Outputs random integers from a uniform distribution.
+///
+/// The generated values are uniform integers covering the whole range of `dtype`. 
+///
+/// - Parameters:
+///   - resource: The handle of the resource variable that stores the state of the RNG.
+///   - algorithm: The RNG algorithm.
+///   - shape: The shape of the output tensor.
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statefulUniformFullInt<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  algorithm: Tensor<Int64>,
+  shape: Tensor<ShapeDtype>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("StatefulUniformFullInt")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(algorithm)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Outputs random integers from a uniform distribution.
+///
+/// The generated values are uniform integers in the range `[minval, maxval)`.
+/// The lower bound `minval` is included in the range, while the upper bound
+/// `maxval` is excluded.
+///
+/// The random integers are slightly biased unless `maxval - minval` is an exact
+/// power of two.  The bias is small for values of `maxval - minval` significantly
+/// smaller than the range of the output (either `2^32` or `2^64`).
+///
+/// - Parameters:
+///   - resource: The handle of the resource variable that stores the state of the RNG.
+///   - algorithm: The RNG algorithm.
+///   - shape: The shape of the output tensor.
+///   - minval: Minimum value (inclusive, scalar).
+///   - maxval: Maximum value (exclusive, scalar).
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statefulUniformInt<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+  resource: ResourceHandle,
+  algorithm: Tensor<Int64>,
+  shape: Tensor<ShapeDtype>,
+  minval: Tensor<Dtype>,
+  maxval: Tensor<Dtype>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("StatefulUniformInt")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
+  let _ = op.addInput(resource)
+  let _ = op.addInput(algorithm)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(minval)
+  let _ = op.addInput(maxval)
+  return op.execute(Int(1))
+}
+
+/// output = cond ? then_branch(input) : else_branch(input)
+///
+/// - Parameters:
+///   - cond:       A Tensor. If the tensor is a scalar of non-boolean type, the
+///           scalar is converted to a boolean according to the
+///           following rule: if the scalar is a numerical value, non-zero means
+///           `True` and zero means False; if the scalar is a string, non-empty
+///           means `True` and empty means `False`. If the tensor is not a scalar,
+///           being empty means False and being non-empty means True.
+///
+///           This should only be used when the if then/else body functions do not
+///           have stateful ops.
+///   - input: A list of input tensors.
+///
+/// - Attrs:
+///   - Tin: A list of input types.
+///   - Tout: A list of output types.
+///   - then_branch:       A function that takes 'inputs' and returns a list of tensors, whose
+///           types are the same as what else_branch returns.
+///   - else_branch:     A function that takes 'inputs' and returns a list of tensors, whose
+///         types are the same as what then_branch returns.
+///
+/// - Output output: A list of return values.
+@inlinable @inline(__always)
+public static func statelessIf<
+    Tcond: TensorFlowScalar,
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    ThenbranchIn: TensorGroup,
+    ThenbranchOut: TensorGroup,
+    ElsebranchIn: TensorGroup,
+    ElsebranchOut: TensorGroup
+>(
+  cond: Tensor<Tcond>,
+  _ input: Tin,
+  thenBranch: (ThenbranchIn) -> ThenbranchOut,
+  elseBranch: (ElsebranchIn) -> ElsebranchOut
+) -> Tout {
+  let op = TFE_Op("StatelessIf")
+  op.setAttr("Tcond", Tcond.tensorFlowDataType)
+  op.setAttr("Tin", input._typeList)
+  op.setAttr("Tout", Tout._typeList)
+  op.setAttr("then_branch", thenBranch)
+  op.setAttr("else_branch", elseBranch)
+  let _ = op.addInput(cond)
+  let _ = op.addInputList(input)
+  return op.execute(Int(Tout._typeList.count))
+}
+
+/// Draws samples from a multinomial distribution.
+///
+/// - Parameters:
+///   - logits: 2-D Tensor with shape `[batch_size, num_classes]`.  Each slice `[i, :]`
+///     represents the unnormalized log probabilities for all classes.
+///   - num_samples: 0-D.  Number of independent samples to draw for each row slice.
+///   - seed: 2 seeds (shape [2]).
+///
+/// - Output output: 2-D Tensor with shape `[batch_size, num_samples]`.  Each slice `[i, :]`
+///   contains the drawn class labels with range `[0, num_classes)`.
+@inlinable @inline(__always)
+public static func statelessMultinomial<
+    T: Numeric & TensorFlowScalar,
+    Tseed: BinaryInteger & TensorFlowScalar,
+    OutputDtype: BinaryInteger & TensorFlowScalar
+>(
+  logits: Tensor<T>,
+  numSamples: Tensor<Int32>,
+  seed: Tensor<Tseed>
+) -> Tensor<OutputDtype> {
+  let op = TFE_Op("StatelessMultinomial")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tseed", Tseed.tensorFlowDataType)
+  op.setAttr("output_dtype", OutputDtype.tensorFlowDataType)
+  let _ = op.addInput(logits)
+  let _ = op.addInput(numSamples)
+  let _ = op.addInput(seed)
+  return op.execute(Int(1))
+}
+
+/// Outputs deterministic pseudorandom values from a normal distribution.
+///
+/// The generated values will have mean 0 and standard deviation 1.
+///
+/// The outputs are a deterministic function of `shape` and `seed`.
+///
+/// - Parameters:
+///   - shape: The shape of the output tensor.
+///   - seed: 2 seeds (shape [2]).
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statelessRandomNormal<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar,
+    Tseed: BinaryInteger & TensorFlowScalar
+>(
+  shape: Tensor<T>,
+  seed: Tensor<Tseed>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("StatelessRandomNormal")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tseed", Tseed.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(seed)
+  return op.execute(Int(1))
+}
+
+/// Outputs deterministic pseudorandom random values from a uniform distribution.
+///
+/// The generated values follow a uniform distribution in the range `[0, 1)`. The
+/// lower bound 0 is included in the range, while the upper bound 1 is excluded.
+///
+/// The outputs are a deterministic function of `shape` and `seed`.
+///
+/// - Parameters:
+///   - shape: The shape of the output tensor.
+///   - seed: 2 seeds (shape [2]).
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statelessRandomUniform<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar,
+    Tseed: BinaryInteger & TensorFlowScalar
+>(
+  shape: Tensor<T>,
+  seed: Tensor<Tseed>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("StatelessRandomUniform")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tseed", Tseed.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(seed)
+  return op.execute(Int(1))
+}
+
+/// Outputs deterministic pseudorandom random integers from a uniform distribution.
+///
+/// The generated values follow a uniform distribution in the range `[minval, maxval)`.
+///
+/// The outputs are a deterministic function of `shape`, `seed`, `minval`, and `maxval`.
+///
+/// - Parameters:
+///   - shape: The shape of the output tensor.
+///   - seed: 2 seeds (shape [2]).
+///   - minval: Minimum value (inclusive, scalar).
+///   - maxval: Maximum value (exclusive, scalar).
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statelessRandomUniformInt<
+    Dtype: BinaryInteger & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar,
+    Tseed: BinaryInteger & TensorFlowScalar
+>(
+  shape: Tensor<T>,
+  seed: Tensor<Tseed>,
+  minval: Tensor<Dtype>,
+  maxval: Tensor<Dtype>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("StatelessRandomUniformInt")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tseed", Tseed.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(seed)
+  let _ = op.addInput(minval)
+  let _ = op.addInput(maxval)
+  return op.execute(Int(1))
+}
+
+/// Outputs deterministic pseudorandom values from a truncated normal distribution.
+///
+/// The generated values follow a normal distribution with mean 0 and standard
+/// deviation 1, except that values whose magnitude is more than 2 standard
+/// deviations from the mean are dropped and re-picked.
+///
+/// The outputs are a deterministic function of `shape` and `seed`.
+///
+/// - Parameters:
+///   - shape: The shape of the output tensor.
+///   - seed: 2 seeds (shape [2]).
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statelessTruncatedNormal<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar,
+    Tseed: BinaryInteger & TensorFlowScalar
+>(
+  shape: Tensor<T>,
+  seed: Tensor<Tseed>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("StatelessTruncatedNormal")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tseed", Tseed.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(seed)
+  return op.execute(Int(1))
+}
+
+/// output = input; While (Cond(output)) { output = Body(output) }
+///
+/// - Parameter input: A list of input tensors whose types are T.
+///
+/// - Attrs:
+///   - T: dtype in use.
+///   - cond:       A function takes 'input' and returns a tensor.  If the tensor is
+///           a scalar of non-boolean, the scalar is converted to a boolean
+///           according to the following rule: if the scalar is a numerical
+///           value, non-zero means True and zero means False; if the scalar is
+///           a string, non-empty means True and empty means False. If the
+///           tensor is not a scalar, non-emptiness means True and False
+///           otherwise.
+///
+///           This should only be used when the while condition and body functions
+///           do not have stateful ops.
+///   - body:       A function that takes a list of tensors and returns another
+///           list of tensors. Both lists have the same types as specified
+///           by T.
+///
+/// - Output output: A list of output tensors whose types are T.
+@inlinable @inline(__always)
+public static func statelessWhile<
+    T: TensorArrayProtocol,
+    CondIn: TensorGroup,
+    CondOut: TensorGroup,
+    BodyIn: TensorGroup,
+    BodyOut: TensorGroup
+>(
+  _ input: T,
+  cond: (CondIn) -> CondOut,
+  body: (BodyIn) -> BodyOut
+) -> T {
+  let op = TFE_Op("StatelessWhile")
+  op.setAttr("T", input._typeList)
+  op.setAttr("cond", cond)
+  op.setAttr("body", body)
+  let _ = op.addInputList(input)
+  return op.execute(Int(input._typeList.count))
+}
+
+/// Check if the input matches the regex pattern.
+///
+/// The input is a string tensor of any shape. The pattern is the
+/// regular expression to be matched with every element of the input tensor.
+/// The boolean values (True or False) of the output tensor indicate
+/// if the input matches the regex pattern provided.
+///
+/// The pattern follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
+///
+/// - Parameter input: A string tensor of the text to be processed.
+///
+/// - Attr pattern: The regular expression to match the input.
+///
+/// - Output output: A bool tensor with the same shape as `input`.
+@inlinable @inline(__always)
+public static func staticRegexFullMatch(
+  _ input: StringTensor,
+  pattern: String
+) -> Tensor<Bool> {
+  let op = TFE_Op("StaticRegexFullMatch")
+  op.setAttr("pattern", pattern)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Replaces the match of pattern in input with rewrite.
+///
+/// It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
+///
+/// - Parameter input: The text to be processed.
+///
+/// - Attrs:
+///   - pattern: The regular expression to match the input.
+///   - rewrite: The rewrite to be applied to the matched expression.
+///   - replace_global: If True, the replacement is global, otherwise the replacement
+///     is done only on the first match.
+///
+/// - Output output: The text after applying pattern and rewrite.
+@inlinable @inline(__always)
+public static func staticRegexReplace(
+  _ input: StringTensor,
+  pattern: String,
+  rewrite: String,
+  replaceGlobal: Bool = true
+) -> StringTensor {
+  let op = TFE_Op("StaticRegexReplace")
+  op.setAttr("pattern", pattern)
+  op.setAttr("rewrite", rewrite)
+  op.setAttr("replace_global", replaceGlobal)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func statsAggregatorHandleV2(
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("StatsAggregatorHandleV2")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Set a summary_writer_interface to record statistics using given stats_aggregator.
+@inlinable @inline(__always)
+public static func statsAggregatorSetSummaryWriter(
+  statsAggregator: ResourceHandle,
+  summary: ResourceHandle
+) {
+  let op = TFE_Op("StatsAggregatorSetSummaryWriter")
+  let _ = op.addInput(statsAggregator)
+  let _ = op.addInput(summary)
+  op.execute()
+}
+
+/// 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.
+@inlinable @inline(__always)
+public static func stopGradient<T: TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("StopGradient")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Return a strided slice from `input`.
+///
+/// Note, most python users will want to use the Python `Tensor.__getitem__`
+/// or `Variable.__getitem__` rather than this op directly.
+///
+/// The goal of this op is to produce a new tensor with a subset of
+/// the elements from the `n` dimensional `input` tensor. The subset is chosen using
+/// a sequence of `m` sparse range specifications encoded into the arguments
+/// of this function. Note, in some cases
+/// `m` could be equal to `n`, but this need not be the case. Each
+/// range specification entry can be one of the following:
+///
+/// - An ellipsis (...). Ellipses are used to imply zero or more
+///   dimensions of full-dimension selection and are produced using
+///   `ellipsis_mask`. For example, `foo[...]` is the identity slice.
+///
+/// - A new axis. This is used to insert a new shape=1 dimension and is
+///   produced using `new_axis_mask`. For example, `foo[:, ...]` where
+///   `foo` is shape `(3, 4)` produces a `(1, 3, 4)` tensor.
+///
+///
+/// - A range `begin:end:stride`. This is used to specify how much to choose from
+///   a given dimension. `stride` can be any integer but 0.  `begin` is an integer
+///   which represents the index of the first value to select while `end` represents
+///   the index of the last value to select. The number of values selected in each
+///   dimension is `end - begin` if `stride > 0` and `begin - end` if `stride < 0`.
+///   `begin` and `end` can be negative where `-1` is the last element, `-2` is
+///   the second to last. `begin_mask` controls whether to replace the explicitly
+///   given `begin` with an implicit effective value of `0` if `stride > 0` and
+///   `-1` if `stride < 0`. `end_mask` is analogous but produces the number
+///   required to create the largest open interval. For example, given a shape
+///   `(3,)` tensor `foo[:]`, the effective `begin` and `end` are `0` and `3`. Do
+///   not assume this is equivalent to `foo[0:-1]` which has an effective `begin`
+///   and `end` of `0` and `2`. Another example is `foo[-2::-1]` which reverses the
+///   first dimension of a tensor while dropping the last two (in the original
+///   order elements). For example `foo = [1,2,3,4]; foo[-2::-1]` is `[4,3]`.
+///
+/// - A single index. This is used to keep only elements that have a given
+///   index. For example (`foo[2, :]` on a shape `(5,6)` tensor produces a
+///   shape `(6,)` tensor. This is encoded in `begin` and `end` and
+///   `shrink_axis_mask`.
+///
+/// Each conceptual range specification is encoded in the op's argument. This
+/// encoding is best understand by considering a non-trivial example. In
+/// particular,
+/// `foo[1, 2:4, None, ..., :-3:-1, :]` will be encoded as
+///
+/// ```
+/// begin = [1, 2, x, x, 0, x] # x denotes don't care (usually 0)
+/// end = [2, 4, x, x, -3, x]
+/// strides = [1, 1, x, x, -1, 1]
+/// begin_mask = 1<<4 | 1 << 5 = 48
+/// end_mask = 1<<5 = 32
+/// ellipsis_mask = 1<<3 = 8
+/// new_axis_mask = 1<<2 4
+/// shrink_axis_mask = 1<<0
+/// ```
+///
+/// In this case if `foo.shape` is (5, 5, 5, 5, 5, 5) the final shape of
+/// the slice becomes (2, 1, 5, 5, 2, 5).
+/// Let us walk step by step through each argument specification.
+///
+/// 1.  The first argument in the example slice is turned into `begin = 1` and
+/// `end = begin + 1 = 2`. To disambiguate from the original spec `2:4` we
+/// also set the appropriate bit in `shrink_axis_mask`.
+///
+/// 2. `2:4` is contributes 2, 4, 1 to begin, end, and stride. All masks have
+/// zero bits contributed.
+///
+/// 3. None is a synonym for `tf.newaxis`. This means insert a dimension of size 1
+/// dimension in the final shape. Dummy values are contributed to begin,
+/// end and stride, while the new_axis_mask bit is set.
+///
+/// 4. `...` grab the full ranges from as many dimensions as needed to
+/// fully specify a slice for every dimension of the input shape.
+///
+/// 5. `:-3:-1` shows the use of negative indices. A negative index `i` associated
+/// with a dimension that has shape `s` is converted to a positive index
+/// `s + i`. So `-1` becomes `s-1` (i.e. the last element). This conversion
+/// is done internally so begin, end and strides receive x, -3, and -1.
+/// The appropriate begin_mask bit is set to indicate the start range is the
+/// full range (ignoring the x).
+///
+/// 6. `:` indicates that the entire contents of the corresponding dimension
+/// is selected. This is equivalent to `::` or `0::1`. begin, end, and strides
+/// receive 0, 0, and 1, respectively. The appropriate bits in `begin_mask` and
+/// `end_mask` are also set.
+///
+/// *Requirements*:
+///   `0 != strides[i] for i in [0, m)`
+///   `ellipsis_mask must be a power of two (only one ellipsis)`
+///
+/// - Parameters:
+///   - begin: `begin[k]` specifies the offset into the `k`th range specification.
+///     The exact dimension this corresponds to will be determined by context.
+///     Out-of-bounds values will be silently clamped. If the `k`th bit of
+///     `begin_mask` then `begin[k]` is ignored and the full range of the
+///     appropriate dimension is used instead. Negative values causes indexing
+///     to start from the highest element e.g. If `foo==[1,2,3]` then `foo[-1]==3`.
+///   - end: `end[i]` is like `begin` with the exception that `end_mask` is
+///     used to determine full ranges.
+///   - strides: `strides[i]` specifies the increment in the `i`th specification
+///     after extracting a given element. Negative indices will reverse
+///     the original order. Out or range values are
+///     clamped to `[0,dim[i]) if slice[i]>0` or `[-1,dim[i]-1] if slice[i] < 0`
+///
+/// - Attrs:
+///   - begin_mask: a bitmask where a bit i being 1 means to ignore the begin
+///     value and instead use the largest interval possible. At runtime
+///     begin[i] will be replaced with `[0, n-1)` if `stride[i] > 0` or
+///     `[-1, n-1]` if `stride[i] < 0`
+///   - end_mask: analogous to `begin_mask`
+///   - ellipsis_mask: a bitmask where bit `i` being 1 means the `i`th
+///     position is actually an ellipsis. One bit at most can be 1.
+///     If `ellipsis_mask == 0`, then an implicit ellipsis mask of `1 << (m+1)`
+///     is provided. This means that `foo[3:5] == foo[3:5, ...]`. An ellipsis
+///     implicitly creates as many range specifications as necessary to fully
+///     specify the sliced range for every dimension. For example for a 4-dimensional
+///     tensor `foo` the slice `foo[2, ..., 5:8]` implies `foo[2, :, :, 5:8]`.
+///   - new_axis_mask: a bitmask where bit `i` being 1 means the `i`th
+///     specification creates a new shape 1 dimension. For example
+///     `foo[:4, tf.newaxis, :2]` would produce a shape `(4, 1, 2)` tensor.
+///   - shrink_axis_mask: a bitmask where bit `i` implies that the `i`th
+///     specification should shrink the dimensionality. begin and end
+///     must imply a slice of size 1 in the dimension. For example in
+///     python one might do `foo[:, 3, :]` which would result in
+///     `shrink_axis_mask` being 2.
+@inlinable @inline(__always)
+public static func stridedSlice<
+    T: TensorFlowScalar,
+    Index: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  begin: Tensor<Index>,
+  end: Tensor<Index>,
+  strides: Tensor<Index>,
+  beginMask: Int64 = 0,
+  endMask: Int64 = 0,
+  ellipsisMask: Int64 = 0,
+  newAxisMask: Int64 = 0,
+  shrinkAxisMask: Int64 = 0
+) -> Tensor<T> {
+  let op = TFE_Op("StridedSlice")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Index", Index.tensorFlowDataType)
+  op.setAttr("begin_mask", beginMask)
+  op.setAttr("end_mask", endMask)
+  op.setAttr("ellipsis_mask", ellipsisMask)
+  op.setAttr("new_axis_mask", newAxisMask)
+  op.setAttr("shrink_axis_mask", shrinkAxisMask)
+  let _ = op.addInput(input)
+  let _ = op.addInput(begin)
+  let _ = op.addInput(end)
+  let _ = op.addInput(strides)
+  return op.execute(Int(1))
+}
+
+/// Returns the gradient of `StridedSlice`.
+///
+/// Since `StridedSlice` cuts out pieces of its `input` which is size
+/// `shape`, its gradient will have the same shape (which is passed here
+/// as `shape`). The gradient will be zero in any element that the slice
+/// does not select.
+///
+/// Arguments are the same as StridedSliceGrad with the exception that
+/// `dy` is the input gradient to be propagated and `shape` is the
+/// shape of `StridedSlice`'s `input`.
+@inlinable @inline(__always)
+public static func stridedSliceGrad<
+    T: TensorFlowScalar,
+    Index: BinaryInteger & TensorFlowScalar
+>(
+  shape: Tensor<Index>,
+  begin: Tensor<Index>,
+  end: Tensor<Index>,
+  strides: Tensor<Index>,
+  dy: Tensor<T>,
+  beginMask: Int64 = 0,
+  endMask: Int64 = 0,
+  ellipsisMask: Int64 = 0,
+  newAxisMask: Int64 = 0,
+  shrinkAxisMask: Int64 = 0
+) -> Tensor<T> {
+  let op = TFE_Op("StridedSliceGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Index", Index.tensorFlowDataType)
+  op.setAttr("begin_mask", beginMask)
+  op.setAttr("end_mask", endMask)
+  op.setAttr("ellipsis_mask", ellipsisMask)
+  op.setAttr("new_axis_mask", newAxisMask)
+  op.setAttr("shrink_axis_mask", shrinkAxisMask)
+  let _ = op.addInput(shape)
+  let _ = op.addInput(begin)
+  let _ = op.addInput(end)
+  let _ = op.addInput(strides)
+  let _ = op.addInput(dy)
+  return op.execute(Int(1))
+}
+
+/// Formats a string template using a list of tensors.
+///
+/// Formats a string template using a list of tensors, pretty-printing tensor summaries.
+///
+/// - Parameter inputs: The list of tensors to format into the placeholder string.
+///
+/// - Attrs:
+///   - template: A string, the template to format tensor summaries into.
+///   - placeholder: A string, at each placeholder in the template a subsequent tensor summary will be inserted.
+///   - summarize: When formatting the tensor summaries print the first and last summarize entries of each tensor dimension.
+///
+/// - Output output: = The resulting string scalar.
+@inlinable @inline(__always)
+public static func stringFormat<T: TensorArrayProtocol>(
+  inputs: T,
+  template: String = "%s",
+  placeholder: String = "%s",
+  summarize: Int64 = 3
+) -> StringTensor {
+  let op = TFE_Op("StringFormat")
+  op.setAttr("T", inputs._typeList)
+  op.setAttr("template", template)
+  op.setAttr("placeholder", placeholder)
+  op.setAttr("summarize", summarize)
+  let _ = op.addInputList(inputs)
+  return op.execute(Int(1))
+}
+
+/// Joins the strings in the given list of string tensors into one tensor;
+///
+/// with the given separator (default is an empty separator).
+///
+/// - Parameter inputs: A list of string tensors.  The tensors must all have the same shape,
+///   or be scalars.  Scalars may be mixed in; these will be broadcast to the shape
+///   of non-scalar inputs.
+///
+/// - Attr separator: string, an optional join separator.
+@inlinable @inline(__always)
+public static func stringJoin(
+  inputs: [StringTensor],
+  separator: String
+) -> StringTensor {
+  let op = TFE_Op("StringJoin")
+  op.setAttr("N", inputs.count)
+  op.setAttr("separator", separator)
+  let _ = op.addInputList(inputs)
+  return op.execute(Int(1))
+}
+
+/// String lengths of `input`.
+///
+/// Computes the length of each string given in the input tensor.
+///
+/// - Parameter input: The string for which to compute the length.
+///
+/// - Attr unit: The unit that is counted to compute string length.  One of: `"BYTE"` (for
+///   the number of bytes in each string) or `"UTF8_CHAR"` (for the number of UTF-8
+///   encoded Unicode code points in each string).  Results are undefined
+///   if `unit=UTF8_CHAR` and the `input` strings do not contain structurally
+///   valid UTF-8.
+///
+/// - Output output: Integer tensor that has the same shape as `input`. The output contains the
+///   element-wise string lengths of `input`.
+@inlinable @inline(__always)
+public static func stringLength(
+  _ input: StringTensor,
+  unit: Unit = .byte
+) -> Tensor<Int32> {
+  let op = TFE_Op("StringLength")
+  op.setAttr("unit", unit.cName)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func stringListAttr(
+  _ a: [String],
+  _ b: String
+) {
+  let op = TFE_Op("StringListAttr")
+  op.setAttr("a", a)
+  op.setAttr("b", b)
+  op.execute()
+}
+
+/// Split elements of `input` based on `delimiter` into a `SparseTensor`.
+///
+/// Let N be the size of source (typically N will be the batch size). Split each
+/// element of `input` based on `delimiter` and return a `SparseTensor`
+/// containing the splitted tokens. Empty tokens are ignored.
+///
+/// `delimiter` can be empty, or a string of split characters. If `delimiter` is an
+///  empty string, each element of `input` is split into individual single-byte
+///  character strings, including splitting of UTF-8 multibyte sequences. Otherwise
+///  every character of `delimiter` is a potential split point.
+///
+/// For example:
+///   N = 2, input[0] is 'hello world' and input[1] is 'a b c', then the output
+///   will be
+///
+///   indices = [0, 0;
+///              0, 1;
+///              1, 0;
+///              1, 1;
+///              1, 2]
+///   shape = [2, 3]
+///   values = ['hello', 'world', 'a', 'b', 'c']
+///
+/// - Parameters:
+///   - input: 1-D. Strings to split.
+///   - delimiter: 0-D. Delimiter characters (bytes), or empty string.
+///
+/// - Attr skip_empty: A `bool`. If `True`, skip the empty strings from the result.
+///
+/// - Outputs:
+///   - indices: A dense matrix of int64 representing the indices of the sparse tensor.
+///   - values: A vector of strings corresponding to the splited values.
+///   - shape: a length-2 vector of int64 representing the shape of the sparse
+///     tensor, where the first value is N and the second value is the maximum number
+///     of tokens in a single input entry.
+@inlinable @inline(__always)
+public static func stringSplit(
+  _ input: StringTensor,
+  delimiter: StringTensor,
+  skipEmpty: Bool = true
+) -> (indices: Tensor<Int64>, values: StringTensor, shape: Tensor<Int64>) {
+  let op = TFE_Op("StringSplit")
+  op.setAttr("skip_empty", skipEmpty)
+  let _ = op.addInput(input)
+  let _ = op.addInput(delimiter)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Split elements of `source` based on `sep` into a `SparseTensor`.
+///
+/// Let N be the size of source (typically N will be the batch size). Split each
+/// element of `source` based on `sep` and return a `SparseTensor`
+/// containing the split tokens. Empty tokens are ignored.
+///
+/// For example, N = 2, source[0] is 'hello world' and source[1] is 'a b c',
+/// then the output will be
+/// ```
+/// st.indices = [0, 0;
+///               0, 1;
+///               1, 0;
+///               1, 1;
+///               1, 2]
+/// st.shape = [2, 3]
+/// st.values = ['hello', 'world', 'a', 'b', 'c']
+/// ```
+///
+/// If `sep` is given, consecutive delimiters are not grouped together and are
+/// deemed to delimit empty strings. For example, source of `"1<>2<><>3"` and
+/// sep of `"<>"` returns `["1", "2", "", "3"]`. If `sep` is None or an empty
+/// string, consecutive whitespace are regarded as a single separator, and the
+/// result will contain no empty strings at the startor end if the string has
+/// leading or trailing whitespace.
+///
+/// Note that the above mentioned behavior matches python's str.split.
+///
+/// - Parameters:
+///   - input: `1-D` string `Tensor`, the strings to split.
+///   - sep: `0-D` string `Tensor`, the delimiter character.
+///
+/// - Attr maxsplit: An `int`. If `maxsplit > 0`, limit of the split of the result.
+@inlinable @inline(__always)
+public static func stringSplitV2(
+  _ input: StringTensor,
+  sep: StringTensor,
+  maxsplit: Int64 = -1
+) -> (indices: Tensor<Int64>, values: StringTensor, shape: Tensor<Int64>) {
+  let op = TFE_Op("StringSplitV2")
+  op.setAttr("maxsplit", maxsplit)
+  let _ = op.addInput(input)
+  let _ = op.addInput(sep)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Strip leading and trailing whitespaces from the Tensor.
+///
+/// - Parameter input: A string `Tensor` of any shape.
+///
+/// - Output output: A string `Tensor` of the same shape as the input.
+@inlinable @inline(__always)
+public static func stringStrip(
+  _ input: StringTensor
+) -> StringTensor {
+  let op = TFE_Op("StringStrip")
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Converts each string in the input Tensor to its hash mod by a number of buckets.
+///
+/// The hash function is deterministic on the content of the string within the
+/// process.
+///
+/// Note that the hash function may change from time to time.
+/// This functionality will be deprecated and it's recommended to use
+/// `tf.string_to_hash_bucket_fast()` or `tf.string_to_hash_bucket_strong()`.
+///
+/// - Attr num_buckets: The number of buckets.
+///
+/// - Output output: A Tensor of the same shape as the input `string_tensor`.
+@inlinable @inline(__always)
+public static func stringToHashBucket(
+  stringTensor: StringTensor,
+  numBuckets: Int64
+) -> Tensor<Int64> {
+  let op = TFE_Op("StringToHashBucket")
+  op.setAttr("num_buckets", numBuckets)
+  let _ = op.addInput(stringTensor)
+  return op.execute(Int(1))
+}
+
+/// Converts each string in the input Tensor to its hash mod by a number of buckets.
+///
+/// The hash function is deterministic on the content of the string within the
+/// process and will never change. However, it is not suitable for cryptography.
+/// This function may be used when CPU time is scarce and inputs are trusted or
+/// unimportant. There is a risk of adversaries constructing inputs that all hash
+/// to the same bucket. To prevent this problem, use a strong hash function with
+/// `tf.string_to_hash_bucket_strong`.
+///
+/// - Parameter input: The strings to assign a hash bucket.
+///
+/// - Attr num_buckets: The number of buckets.
+///
+/// - Output output: A Tensor of the same shape as the input `string_tensor`.
+@inlinable @inline(__always)
+public static func stringToHashBucketFast(
+  _ input: StringTensor,
+  numBuckets: Int64
+) -> Tensor<Int64> {
+  let op = TFE_Op("StringToHashBucketFast")
+  op.setAttr("num_buckets", numBuckets)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Converts each string in the input Tensor to its hash mod by a number of buckets.
+///
+/// The hash function is deterministic on the content of the string within the
+/// process. The hash function is a keyed hash function, where attribute `key`
+/// defines the key of the hash function. `key` is an array of 2 elements.
+///
+/// A strong hash is important when inputs may be malicious, e.g. URLs with
+/// additional components. Adversaries could try to make their inputs hash to the
+/// same bucket for a denial-of-service attack or to skew the results. A strong
+/// hash prevents this by making it difficult, if not infeasible, to compute inputs
+/// that hash to the same bucket. This comes at a cost of roughly 4x higher compute
+/// time than `tf.string_to_hash_bucket_fast`.
+///
+/// - Parameter input: The strings to assign a hash bucket.
+///
+/// - Attrs:
+///   - num_buckets: The number of buckets.
+///   - key: The key for the keyed hash function passed as a list of two uint64
+///     elements.
+///
+/// - Output output: A Tensor of the same shape as the input `string_tensor`.
+@inlinable @inline(__always)
+public static func stringToHashBucketStrong(
+  _ input: StringTensor,
+  numBuckets: Int64,
+  key: [Int32]
+) -> Tensor<Int64> {
+  let op = TFE_Op("StringToHashBucketStrong")
+  op.setAttr("num_buckets", numBuckets)
+  op.setAttr("key", key)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Converts each string in the input Tensor to the specified numeric type.
+///
+/// (Note that int32 overflow results in an error while float overflow
+/// results in a rounded value.)
+///
+/// - Attr out_type: The numeric type to interpret each string in `string_tensor` as.
+///
+/// - Output output: A Tensor of the same shape as the input `string_tensor`.
+@inlinable @inline(__always)
+public static func stringToNumber<OutType: Numeric & TensorFlowScalar>(
+  stringTensor: StringTensor
+) -> Tensor<OutType> {
+  let op = TFE_Op("StringToNumber")
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(stringTensor)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func stubResourceHandleOp(
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("StubResourceHandleOp")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Returns x - y element-wise.
+///
+/// *NOTE*: `Subtract` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func sub<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Sub")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Return substrings from `Tensor` of strings.
+///
+/// For each string in the input `Tensor`, creates a substring starting at index
+/// `pos` with a total length of `len`.
+///
+/// If `len` defines a substring that would extend beyond the length of the input
+/// string, then as many characters as possible are used.
+///
+/// A negative `pos` indicates distance within the string backwards from the end.
+///
+/// If `pos` specifies an index which is out of range for any of the input strings,
+/// then an `InvalidArgumentError` is thrown.
+///
+/// `pos` and `len` must have the same shape, otherwise a `ValueError` is thrown on
+/// Op creation.
+///
+/// *NOTE*: `Substr` supports broadcasting up to two dimensions. More about
+/// broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+///
+/// ---
+///
+/// Examples
+///
+/// Using scalar `pos` and `len`:
+///
+/// ```python
+/// input = [b'Hello', b'World']
+/// position = 1
+/// length = 3
+///
+/// output = [b'ell', b'orl']
+/// ```
+///
+/// Using `pos` and `len` with same shape as `input`:
+///
+/// ```python
+/// input = [[b'ten', b'eleven', b'twelve'],
+///          [b'thirteen', b'fourteen', b'fifteen'],
+///          [b'sixteen', b'seventeen', b'eighteen']]
+/// position = [[1, 2, 3],
+///             [1, 2, 3],
+///             [1, 2, 3]]
+/// length =   [[2, 3, 4],
+///             [4, 3, 2],
+///             [5, 5, 5]]
+///
+/// output = [[b'en', b'eve', b'lve'],
+///           [b'hirt', b'urt', b'te'],
+///           [b'ixtee', b'vente', b'hteen']]
+/// ```
+///
+/// Broadcasting `pos` and `len` onto `input`:
+///
+/// ```
+/// input = [[b'ten', b'eleven', b'twelve'],
+///          [b'thirteen', b'fourteen', b'fifteen'],
+///          [b'sixteen', b'seventeen', b'eighteen'],
+///          [b'nineteen', b'twenty', b'twentyone']]
+/// position = [1, 2, 3]
+/// length =   [1, 2, 3]
+///
+/// output = [[b'e', b'ev', b'lve'],
+///           [b'h', b'ur', b'tee'],
+///           [b'i', b've', b'hte'],
+///           [b'i', b'en', b'nty']]
+/// ```
+///
+/// Broadcasting `input` onto `pos` and `len`:
+///
+/// ```
+/// input = b'thirteen'
+/// position = [1, 5, 7]
+/// length =   [3, 2, 1]
+///
+/// output = [b'hir', b'ee', b'n']
+/// ```
+///
+/// - Parameters:
+///   - input: Tensor of strings
+///   - pos: Scalar defining the position of first character in each substring
+///   - len: Scalar defining the number of characters to include in each substring
+///
+/// - Attr unit: The unit that is used to create the substring.  One of: `"BYTE"` (for
+///   defining position and length by bytes) or `"UTF8_CHAR"` (for the UTF-8
+///   encoded Unicode code points).  The default is `"BYTE"`. Results are undefined if
+///   `unit=UTF8_CHAR` and the `input` strings do not contain structurally valid
+///   UTF-8.
+///
+/// - Output output: Tensor of substrings
+@inlinable @inline(__always)
+public static func substr<T: BinaryInteger & TensorFlowScalar>(
+  _ input: StringTensor,
+  pos: Tensor<T>,
+  len: Tensor<T>,
+  unit: Unit = .byte
+) -> StringTensor {
+  let op = TFE_Op("Substr")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("unit", unit.cName)
+  let _ = op.addInput(input)
+  let _ = op.addInput(pos)
+  let _ = op.addInput(len)
+  return op.execute(Int(1))
+}
+
+/// Computes the sum of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///   - input: The tensor to reduce.
+///   - reduction_indices: The dimensions to reduce. Must be in the range
+///     `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func sum<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  reductionIndices: Tensor<Tidx>,
+  keepDims: Bool = false
+) -> Tensor<T> {
+  let op = TFE_Op("Sum")
+  op.setAttr("keep_dims", keepDims)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(reductionIndices)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func summaryWriter(
+  sharedName: String,
+  container: String
+) -> ResourceHandle {
+  let op = TFE_Op("SummaryWriter")
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("container", container)
+  return op.execute(Int(1))
+}
+
+/// Computes the singular value decompositions of one or more matrices.
+///
+/// Computes the SVD of each inner matrix in `input` such that
+/// `input[..., :, :] = u[..., :, :] * diag(s[..., :, :]) * transpose(v[..., :, :])`
+///
+/// ```python
+/// # a is a tensor containing a batch of matrices.
+/// # s is a tensor of singular values for each matrix.
+/// # u is the tensor containing of left singular vectors for each matrix.
+/// # v is the tensor containing of right singular vectors for each matrix.
+/// s, u, v = svd(a)
+/// s, _, _ = svd(a, compute_uv=False)
+/// ```
+///
+/// - Parameter input: A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
+///   form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
+///
+/// - Attrs:
+///   - compute_uv: If true, left and right singular vectors will be
+///     computed and returned in `u` and `v`, respectively.
+///     If false, `u` and `v` are not set and should never referenced.
+///   - full_matrices: If true, compute full-sized `u` and `v`. If false
+///     (the default), compute only the leading `P` singular vectors.
+///     Ignored if `compute_uv` is `False`.
+///
+/// - Outputs:
+///   - s: Singular values. Shape is `[..., P]`.
+///   - u: Left singular vectors. If `full_matrices` is `False` then shape is
+///     `[..., M, P]`; if `full_matrices` is `True` then shape is
+///     `[..., M, M]`. Undefined if `compute_uv` is `False`.
+///   - v: Left singular vectors. If `full_matrices` is `False` then shape is
+///     `[..., N, P]`. If `full_matrices` is `True` then shape is `[..., N, N]`.
+///     Undefined if `compute_uv` is false.
+@inlinable @inline(__always)
+public static func svd<T: FloatingPoint & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  computeUv: Bool = true,
+  fullMatrices: Bool = false
+) -> (s: Tensor<T>, u: Tensor<T>, v: Tensor<T>) {
+  let op = TFE_Op("Svd")
+  op.setAttr("compute_uv", computeUv)
+  op.setAttr("full_matrices", fullMatrices)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Forwards `data` to the output port determined by `pred`.
+///
+/// If `pred` is true, the `data` input is forwarded to `output_true`. Otherwise,
+/// the data goes to `output_false`.
+///
+/// See also `RefSwitch` and `Merge`.
+///
+/// - Parameters:
+///   - data: The tensor to be forwarded to the appropriate output.
+///   - pred: A scalar that specifies which output port will receive data.
+///
+/// - Outputs:
+///   - output_false: If `pred` is false, data will be forwarded to this output.
+///   - output_true: If `pred` is true, data will be forwarded to this output.
+@inlinable @inline(__always)
+public static func switch_<T: TensorFlowScalar>(
+  data: Tensor<T>,
+  pred: Tensor<Bool>
+) -> (outputFalse: Tensor<T>, outputTrue: Tensor<T>) {
+  let op = TFE_Op("Switch")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(pred)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Computes the gradient function for function f via backpropagation.
+///
+/// - Parameter input: a list of input tensors of size N + M;
+///
+/// - Attrs:
+///   - Tin: the type list for the input list.
+///   - Tout: the type list for the input list.
+///   - f: The function we want to compute the gradient for.
+///
+///     The function 'f' must be a numerical function which takes N inputs and
+///     produces M outputs. Its gradient function 'g', which is computed by
+///     this SymbolicGradient op is a function taking N + M inputs and
+///     produces N outputs.
+///
+///     I.e. if we have
+///        (y1, y2, ..., y_M) = f(x1, x2, ..., x_N),
+///     then, g is
+///        (dL/dx1, dL/dx2, ..., dL/dx_N) = g(x1, x2, ..., x_N,
+///                                          dL/dy1, dL/dy2, ..., dL/dy_M),
+///
+///     where L is a scalar-value function of (x1, x2, ..., xN) (e.g., the
+///     loss function). dL/dx_i is the partial derivative of L with respect
+///     to x_i.
+///
+///     (Needs some math expert to say the comment above better.)
+///
+/// - Output output: a list of output tensors of size N;
+@inlinable @inline(__always)
+public static func symbolicGradient<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    FIn: TensorGroup,
+    FOut: TensorGroup
+>(
+  _ input: Tin,
+  f: (FIn) -> FOut
+) -> Tout {
+  let op = TFE_Op("SymbolicGradient")
+  op.setAttr("Tin", input._typeList)
+  op.setAttr("Tout", Tout._typeList)
+  op.setAttr("f", f)
+  let _ = op.addInputList(input)
+  return op.execute(Int(Tout._typeList.count))
+}
+
+/// Creates a dataset that emits the records from one or more TFRecord files.
+///
+/// - Parameters:
+///   - filenames: A scalar or vector containing the name(s) of the file(s) to be
+///     read.
+///   - compression_type: A scalar containing either (i) the empty string (no
+///     compression), (ii) "ZLIB", or (iii) "GZIP".
+///   - buffer_size: A scalar representing the number of bytes to buffer. A value of
+///     0 means no buffering will be performed.
+@inlinable @inline(__always)
+public static func tFRecordDataset(
+  filenames: StringTensor,
+  compressionType: StringTensor,
+  bufferSize: Tensor<Int64>
+) -> VariantHandle {
+  let op = TFE_Op("TFRecordDataset")
+  let _ = op.addInput(filenames)
+  let _ = op.addInput(compressionType)
+  let _ = op.addInput(bufferSize)
+  return op.execute(Int(1))
+}
+
+/// A Reader that outputs the records from a TensorFlow Records file.
+///
+/// - Attrs:
+///   - container: If non-empty, this reader is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this reader is named in the given bucket
+///     with this shared_name. Otherwise, the node name is used instead.
+///
+/// - Output reader_handle: The handle to reference the Reader.
+@inlinable @inline(__always)
+public static func tFRecordReaderV2(
+  container: String,
+  sharedName: String,
+  compressionType: String
+) -> ResourceHandle {
+  let op = TFE_Op("TFRecordReaderV2")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("compression_type", compressionType)
+  return op.execute(Int(1))
+}
+
+/// CompilationResultProto indicating the status of the TPU compilation.
+@inlinable @inline(__always)
+public static func tPUCompilationResult(
+) -> StringTensor {
+  let op = TFE_Op("TPUCompilationResult")
+  
+  return op.execute(Int(1))
+}
+
+/// An op enabling differentiation of TPU Embeddings.
+///
+/// This op simply returns its first input, which is assumed to have been sliced
+/// from the Tensors returned by TPUEmbeddingDequeueActivations. The presence of
+/// this op, and its first argument being a trainable Variable, enables automatic
+/// differentiation of graphs containing embeddings via the TPU Embedding Python
+/// libraries.
+///
+/// - Parameters:
+///   - embedding_variable: A trainable variable, enabling optimizers to find this op.
+///   - sliced_activations: The embedding activations Tensor to return.
+///
+/// - Attrs:
+///   - table_id: The id of the table in the embedding layer configuration from which
+///     these activations were computed.
+///   - lookup_id: Identifier of the set of embedding indices which produced these
+///     activations.
+@inlinable @inline(__always)
+public static func tPUEmbeddingActivations(
+  embeddingVariable: Tensor<Float>,
+  slicedActivations: Tensor<Float>,
+  tableId: Int64,
+  lookupId: Int64
+) -> Tensor<Float> {
+  let op = TFE_Op("TPUEmbeddingActivations")
+  op.setAttr("table_id", tableId)
+  op.setAttr("lookup_id", lookupId)
+  let _ = op.addInput(embeddingVariable)
+  let _ = op.addInput(slicedActivations)
+  return op.execute(Int(1))
+}
+
+/// A TPU core selector Op.
+///
+/// This Op produces a set of TPU cores (for warm-up) or a single TPU core
+/// (for regular inference) to execute the TPU program on. The output is
+/// consumed by TPUPartitionedCall.
+///
+/// - Output device_ordinals: A vector 1 or more TPU cores.
+@inlinable @inline(__always)
+public static func tPUOrdinalSelector(
+) -> Tensor<Int32> {
+  let op = TFE_Op("TPUOrdinalSelector")
+  
+  return op.execute(Int(1))
+}
+
+/// Calls a function placed on a specified TPU device.
+///
+/// - Parameters:
+///   - args: The arguments to the function.
+///   - device_ordinal: The TPU device ordinal to run the function on.
+///
+/// - Attrs:
+///   - Tin: The types of the arguments to the function.
+///   - Tout: The types of the outputs of the function.
+///   - f: The function to call.
+///
+/// - Output output: The output of the function call.
+@inlinable @inline(__always)
+public static func tPUPartitionedCall<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    FIn: TensorGroup,
+    FOut: TensorGroup
+>(
+  args: Tin,
+  deviceOrdinal: Tensor<Int32>,
+  f: (FIn) -> FOut
+) -> Tout {
+  let op = TFE_Op("TPUPartitionedCall")
+  op.setAttr("Tin", args._typeList)
+  op.setAttr("Tout", Tout._typeList)
+  op.setAttr("f", f)
+  let _ = op.addInputList(args)
+  let _ = op.addInput(deviceOrdinal)
+  return op.execute(Int(Tout._typeList.count))
+}
+
+/// Runs replicated computations on a distributed TPU system.
+///
+/// - Parameters:
+///   - inputs: the inputs to 'computation', flattened, in replica-major order.
+///   - broadcast_inputs: additional arguments to broadcast to all replicas. The
+///     broadcast inputs are appended to the per-replica inputs when calling
+///     computation.
+///   - guaranteed_constants: arguments which have been guaranteed to not
+///     change their values during the session lifetime. These contain tensors marked as
+///     constant using the GuaranteeConstOp.
+///
+/// - Attrs:
+///   - computation: a function containing the computation to run.
+///   - num_replicas: the number of replicas of the computation to run.
+///   - num_cores_per_replica: the number of logical cores in each replica.
+///   - topology: A serialized tensorflow.tpu.TopologyProto that describes the TPU
+///     topology.
+///   - use_tpu: a bool indicating if this computation will run on TPU or CPU/GPU.
+///     Currently, only supports a default placement (computation is placed on GPU
+///     if one is available, and on CPU if not).
+///   - device_assignment: a flattened array with shape
+///     [replica, num_cores_per_replica, mesh_dimension] that maps the coordinates
+///     of logical cores in each replica of a computation to physical coordinates in
+///     the TPU topology.
+///   - Tinputs: the types of the arguments to 'computation'.
+///   - Tbroadcast_inputs: the types of the additional arguments to broadcast to all
+///     replicas.
+///   - Tguaranteed_constants: the types of the arguments to 'guaranteed_constants'.
+///   - output_types: the types of the outputs of 'computation'.
+///
+/// - Output outputs: the outputs of 'computation'.
+@inlinable @inline(__always)
+public static func tPUReplicate<
+    ComputationIn: TensorGroup,
+    ComputationOut: TensorGroup,
+    Tinputs: TensorArrayProtocol,
+    TbroadcastInputs: TensorArrayProtocol,
+    TguaranteedConstants: TensorArrayProtocol,
+    OutputTypes: TensorGroup
+>(
+  inputs: Tinputs,
+  broadcastInputs: TbroadcastInputs,
+  variables: [ResourceHandle],
+  guaranteedConstants: TguaranteedConstants,
+  computation: (ComputationIn) -> ComputationOut,
+  numReplicas: Int64,
+  numCoresPerReplica: Int64 = 1,
+  topology: String,
+  useTpu: Bool = true,
+  deviceAssignment: [Int32],
+  hostComputeCore: [String],
+  paddingMap: [String],
+  stepMarkerLocation: String = "STEP_MARK_AT_ENTRY"
+) -> OutputTypes {
+  let op = TFE_Op("TPUReplicate")
+  op.setAttr("computation", computation)
+  op.setAttr("num_replicas", numReplicas)
+  op.setAttr("num_cores_per_replica", numCoresPerReplica)
+  op.setAttr("topology", topology)
+  op.setAttr("use_tpu", useTpu)
+  op.setAttr("device_assignment", deviceAssignment)
+  op.setAttr("host_compute_core", hostComputeCore)
+  op.setAttr("Tinputs", inputs._typeList)
+  op.setAttr("Tbroadcast_inputs", broadcastInputs._typeList)
+  op.setAttr("NumVariables", variables.count)
+  op.setAttr("Tguaranteed_constants", guaranteedConstants._typeList)
+  op.setAttr("output_types", OutputTypes._typeList)
+  op.setAttr("padding_map", paddingMap)
+  op.setAttr("step_marker_location", stepMarkerLocation)
+  let _ = op.addInputList(inputs)
+  let _ = op.addInputList(broadcastInputs)
+  let _ = op.addInputList(variables)
+  let _ = op.addInputList(guaranteedConstants)
+  return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Metadata indicaitng how the TPU computation should be replicated.
+///
+/// - Attrs:
+///   - num_replicas: Number of replicas of the computation
+///   - num_cores_per_replica: Number of cores per replica. Used for model parallelism.
+///   - topology: TopologyProto indicating the topology of the TPU pod slice.
+///   - use_tpu: Whether to place the computation on the TPU.
+///   - device_assignment: The assignment of devices for the computation.
+///   - computation_shape: DEPRECATED. Use num_cores_per_replica instead.
+@inlinable @inline(__always)
+public static func tPUReplicateMetadata(
+  numReplicas: Int64,
+  numCoresPerReplica: Int64 = 1,
+  topology: String,
+  useTpu: Bool = true,
+  deviceAssignment: [Int32],
+  computationShape: [Int32],
+  hostComputeCore: [String],
+  paddingMap: [String],
+  stepMarkerLocation: String = "STEP_MARK_AT_ENTRY"
+) {
+  let op = TFE_Op("TPUReplicateMetadata")
+  op.setAttr("num_replicas", numReplicas)
+  op.setAttr("num_cores_per_replica", numCoresPerReplica)
+  op.setAttr("topology", topology)
+  op.setAttr("use_tpu", useTpu)
+  op.setAttr("device_assignment", deviceAssignment)
+  op.setAttr("computation_shape", computationShape)
+  op.setAttr("host_compute_core", hostComputeCore)
+  op.setAttr("padding_map", paddingMap)
+  op.setAttr("step_marker_location", stepMarkerLocation)
+  op.execute()
+}
+
+/// Connects N inputs to an N-way replicated TPU computation.
+@inlinable @inline(__always)
+public static func tPUReplicatedInput<T: TensorFlowScalar>(
+  inputs: [Tensor<T>]
+) -> Tensor<T> {
+  let op = TFE_Op("TPUReplicatedInput")
+  op.setAttr("N", inputs.count)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInputList(inputs)
+  return op.execute(Int(1))
+}
+
+/// Connects outputs of an N-way replicated computation to N outputs.
+@inlinable @inline(__always)
+public static func tPUReplicatedOutput<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  numReplicas: Int64
+) -> [Tensor<T>] {
+  let op = TFE_Op("TPUReplicatedOutput")
+  op.setAttr("num_replicas", numReplicas)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(numReplicas))
+}
+
+/// Creates a dataset that contains `count` elements from the `input_dataset`.
+///
+/// - Parameter count: A scalar representing the number of elements from the `input_dataset`
+///   that should be taken. A value of `-1` indicates that all of `input_dataset`
+///   is taken.
+@inlinable @inline(__always)
+public static func takeDataset(
+  inputDataset: VariantHandle,
+  count: Tensor<Int64>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("TakeDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(count)
+  return op.execute(Int(1))
+}
+
+/// Read `SparseTensors` from a `SparseTensorsMap` and concatenate them.
+///
+/// The input `sparse_handles` must be an `int64` matrix of shape `[N, 1]` where
+/// `N` is the minibatch size and the rows correspond to the output handles of
+/// `AddSparseToTensorsMap` or `AddManySparseToTensorsMap`.  The ranks of the
+/// original `SparseTensor` objects that went into the given input ops must all
+/// match.  When the final `SparseTensor` is created, it has rank one
+/// higher than the ranks of the incoming `SparseTensor` objects
+/// (they have been concatenated along a new row dimension on the left).
+///
+/// The output `SparseTensor` object's shape values for all dimensions but the
+/// first are the max across the input `SparseTensor` objects' shape values
+/// for the corresponding dimensions.  Its first shape value is `N`, the minibatch
+/// size.
+///
+/// The input `SparseTensor` objects' indices are assumed ordered in
+/// standard lexicographic order.  If this is not the case, after this
+/// step run `SparseReorder` to restore index ordering.
+///
+/// For example, if the handles represent an input, which is a `[2, 3]` matrix
+/// representing two original `SparseTensor` objects:
+///
+/// ```
+///     index = [ 0]
+///             [10]
+///             [20]
+///     values = [1, 2, 3]
+///     shape = [50]
+/// ```
+///
+/// and
+///
+/// ```
+///     index = [ 2]
+///             [10]
+///     values = [4, 5]
+///     shape = [30]
+/// ```
+///
+/// then the final `SparseTensor` will be:
+///
+/// ```
+///     index = [0  0]
+///             [0 10]
+///             [0 20]
+///             [1  2]
+///             [1 10]
+///     values = [1, 2, 3, 4, 5]
+///     shape = [2 50]
+/// ```
+///
+/// - Parameter sparse_handles: 1-D, The `N` serialized `SparseTensor` objects.
+///   Shape: `[N]`.
+///
+/// - Attrs:
+///   - dtype: The `dtype` of the `SparseTensor` objects stored in the
+///     `SparseTensorsMap`.
+///   - container: The container name for the `SparseTensorsMap` read by this op.
+///   - shared_name: The shared name for the `SparseTensorsMap` read by this op.
+///     It should not be blank; rather the `shared_name` or unique Operation name
+///     of the Op that created the original `SparseTensorsMap` should be used.
+///
+/// - Outputs:
+///   - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
+///   - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
+///   - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
+@inlinable @inline(__always)
+public static func takeManySparseFromTensorsMap<Dtype: TensorFlowScalar>(
+  sparseHandles: Tensor<Int64>,
+  container: String,
+  sharedName: String
+) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
+  let op = TFE_Op("TakeManySparseFromTensorsMap")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  let _ = op.addInput(sparseHandles)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes tan of x element-wise.
+@inlinable @inline(__always)
+public static func tan<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Tan")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes hyperbolic tangent of `x` element-wise.
+@inlinable @inline(__always)
+public static func tanh<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Tanh")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Computes the gradient for the tanh of `x` wrt its input.
+///
+/// Specifically, `grad = dy * (1 - y*y)`, where `y = tanh(x)`, and `dy`
+/// is the corresponding input gradient.
+@inlinable @inline(__always)
+public static func tanhGrad<T: FloatingPoint & TensorFlowScalar>(
+  _ y: Tensor<T>,
+  dy: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("TanhGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(y)
+  let _ = op.addInput(dy)
+  return op.execute(Int(1))
+}
+
+/// Deprecated. Use TensorArrayCloseV3
+@inlinable @inline(__always)
+public static func tensorArrayCloseV2(
+  handle: StringTensor
+) {
+  let op = TFE_Op("TensorArrayCloseV2")
+  let _ = op.addInput(handle)
+  op.execute()
+}
+
+/// Delete the TensorArray from its resource container.
+///
+/// This enables the user to close and release the resource in the middle
+/// of a step/run.
+///
+/// - Parameter handle: The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
+@inlinable @inline(__always)
+public static func tensorArrayCloseV3(
+  handle: ResourceHandle
+) {
+  let op = TFE_Op("TensorArrayCloseV3")
+  let _ = op.addInput(handle)
+  op.execute()
+}
+
+/// Deprecated. Use TensorArrayConcatV3
+@inlinable @inline(__always)
+public static func tensorArrayConcatV2<Dtype: TensorFlowScalar>(
+  handle: StringTensor,
+  flowIn: Tensor<Float>,
+  elementShapeExcept0: TensorShape?
+) -> (value: Tensor<Dtype>, lengths: Tensor<Int64>) {
+  let op = TFE_Op("TensorArrayConcatV2")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("element_shape_except0", elementShapeExcept0)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Concat the elements from the TensorArray into value `value`.
+///
+/// Takes `T` elements of shapes
+///
+///   ```
+///   (n0 x d0 x d1 x ...), (n1 x d0 x d1 x ...), ..., (n(T-1) x d0 x d1 x ...)
+///   ```
+///
+/// and concatenates them into a Tensor of shape:
+///
+///   ```(n0 + n1 + ... + n(T-1) x d0 x d1 x ...)```
+///
+/// All elements must have the same shape (excepting the first dimension).
+///
+/// - Parameters:
+///   - handle: The handle to a TensorArray.
+///   - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Attrs:
+///   - dtype: The type of the elem that is returned.
+///   - element_shape_except0: The expected shape of an element, if known,
+///     excluding the first dimension. Used to validate the shapes of
+///     TensorArray elements. If this shape is not fully specified, concatenating
+///     zero-size TensorArrays is an error.
+///
+/// - Outputs:
+///   - value: All of the elements in the TensorArray, concatenated along the first
+///     axis.
+///   - lengths: A vector of the row sizes of the original T elements in the
+///     value output.  In the example above, this would be the values:
+///     `(n1, n2, ..., n(T-1))`.
+@inlinable @inline(__always)
+public static func tensorArrayConcatV3<Dtype: TensorFlowScalar>(
+  handle: ResourceHandle,
+  flowIn: Tensor<Float>,
+  elementShapeExcept0: TensorShape?
+) -> (value: Tensor<Dtype>, lengths: Tensor<Int64>) {
+  let op = TFE_Op("TensorArrayConcatV3")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("element_shape_except0", elementShapeExcept0)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Deprecated. Use TensorArrayGatherV3
+@inlinable @inline(__always)
+public static func tensorArrayGatherV2<Dtype: TensorFlowScalar>(
+  handle: StringTensor,
+  indices: Tensor<Int32>,
+  flowIn: Tensor<Float>,
+  elementShape: TensorShape?
+) -> Tensor<Dtype> {
+  let op = TFE_Op("TensorArrayGatherV2")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("element_shape", elementShape)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Gather specific elements from the TensorArray into output `value`.
+///
+/// All elements selected by `indices` must have the same shape.
+///
+/// - Parameters:
+///   - handle: The handle to a TensorArray.
+///   - indices: The locations in the TensorArray from which to read tensor elements.
+///   - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Attrs:
+///   - dtype: The type of the elem that is returned.
+///   - element_shape: The expected shape of an element, if known. Used to
+///     validate the shapes of TensorArray elements. If this shape is not
+///     fully specified, gathering zero-size TensorArrays is an error.
+///
+/// - Output value: All of the elements in the TensorArray, concatenated along a new
+///   axis (the new dimension 0).
+@inlinable @inline(__always)
+public static func tensorArrayGatherV3<Dtype: TensorFlowScalar>(
+  handle: ResourceHandle,
+  indices: Tensor<Int32>,
+  flowIn: Tensor<Float>,
+  elementShape: TensorShape?
+) -> Tensor<Dtype> {
+  let op = TFE_Op("TensorArrayGatherV3")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("element_shape", elementShape)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Deprecated. Use TensorArrayGradV3
+@inlinable @inline(__always)
+public static func tensorArrayGradV2(
+  handle: StringTensor,
+  flowIn: Tensor<Float>,
+  source: String
+) -> StringTensor {
+  let op = TFE_Op("TensorArrayGradV2")
+  op.setAttr("source", source)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Creates a TensorArray for storing the gradients of values in the given handle.
+///
+/// If the given TensorArray gradient already exists, returns a reference to it.
+///
+/// Locks the size of the original TensorArray by disabling its dynamic size flag.
+///
+/// **A note about the input flow_in:**
+///
+/// The handle flow_in forces the execution of the gradient lookup to occur
+/// only after certain other operations have occurred.  For example, when
+/// the forward TensorArray is dynamically sized, writes to this TensorArray
+/// may resize the object.  The gradient TensorArray is statically sized based
+/// on the size of the forward TensorArray when this operation executes.
+/// Furthermore, the size of the forward TensorArray is frozen by this call.
+/// As a result, the flow is used to ensure that the call to generate the gradient
+/// TensorArray only happens after all writes are executed.
+///
+/// In the case of dynamically sized TensorArrays, gradient computation should
+/// only be performed on read operations that have themselves been chained via
+/// flow to occur only after all writes have executed. That way the final size
+/// of the forward TensorArray is known when this operation is called.
+///
+/// **A note about the source attribute:**
+///
+/// TensorArray gradient calls use an accumulator TensorArray object.  If
+/// multiple gradients are calculated and run in the same session, the multiple
+/// gradient nodes may accidentally flow through the same accumulator TensorArray.
+/// This double counts and generally breaks the TensorArray gradient flow.
+///
+/// The solution is to identify which gradient call this particular
+/// TensorArray gradient is being called in.  This is performed by identifying
+/// a unique string (e.g. "gradients", "gradients_1", ...) from the input
+/// gradient Tensor's name.  This string is used as a suffix when creating
+/// the TensorArray gradient object here (the attribute `source`).
+///
+/// The attribute `source` is added as a suffix to the forward TensorArray's
+/// name when performing the creation / lookup, so that each separate gradient
+/// calculation gets its own TensorArray accumulator.
+///
+/// - Parameters:
+///   - handle: The handle to the forward TensorArray.
+///   - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Attr source: The gradient source string, used to decide which gradient TensorArray
+///   to return.
+@inlinable @inline(__always)
+public static func tensorArrayGradV3(
+  handle: ResourceHandle,
+  flowIn: Tensor<Float>,
+  source: String
+) -> (gradHandle: ResourceHandle, flowOut: Tensor<Float>) {
+  let op = TFE_Op("TensorArrayGradV3")
+  op.setAttr("source", source)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Creates a TensorArray for storing multiple gradients of values in the given handle.
+///
+/// Similar to TensorArrayGradV3. However it creates an accumulator with an
+/// expanded shape compared to the input TensorArray whose gradient is being
+/// computed. This enables multiple gradients for the same TensorArray to be
+/// calculated using the same accumulator.
+///
+/// - Parameters:
+///   - handle: The handle to the forward TensorArray.
+///   - flow_in: A float scalar that enforces proper chaining of operations.
+///   - shape_to_prepend: An int32 vector representing a shape. Elements in the gradient accumulator will
+///     have shape which is this shape_to_prepend value concatenated with shape of the
+///     elements in the TensorArray corresponding to the input handle.
+///
+/// - Attr source: The gradient source string, used to decide which gradient TensorArray
+///   to return.
+@inlinable @inline(__always)
+public static func tensorArrayGradWithShape(
+  handle: ResourceHandle,
+  flowIn: Tensor<Float>,
+  shapeToPrepend: Tensor<Int32>,
+  source: String
+) -> (gradHandle: ResourceHandle, flowOut: Tensor<Float>) {
+  let op = TFE_Op("TensorArrayGradWithShape")
+  op.setAttr("source", source)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(flowIn)
+  let _ = op.addInput(shapeToPrepend)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Deprecated. Use TensorArrayReadV3
+@inlinable @inline(__always)
+public static func tensorArrayReadV2<Dtype: TensorFlowScalar>(
+  handle: StringTensor,
+  index: Tensor<Int32>,
+  flowIn: Tensor<Float>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("TensorArrayReadV2")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(index)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Read an element from the TensorArray into output `value`.
+///
+/// - Parameters:
+///   - handle: The handle to a TensorArray.
+///   - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Attr dtype: The type of the elem that is returned.
+///
+/// - Output value: The tensor that is read from the TensorArray.
+@inlinable @inline(__always)
+public static func tensorArrayReadV3<Dtype: TensorFlowScalar>(
+  handle: ResourceHandle,
+  index: Tensor<Int32>,
+  flowIn: Tensor<Float>
+) -> Tensor<Dtype> {
+  let op = TFE_Op("TensorArrayReadV3")
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(index)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Deprecated. Use TensorArrayScatterV3
+@inlinable @inline(__always)
+public static func tensorArrayScatterV2<T: TensorFlowScalar>(
+  handle: StringTensor,
+  indices: Tensor<Int32>,
+  value: Tensor<T>,
+  flowIn: Tensor<Float>
+) -> Tensor<Float> {
+  let op = TFE_Op("TensorArrayScatterV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(value)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Scatter the data from the input value into specific TensorArray elements.
+///
+/// `indices` must be a vector, its length must match the first dim of `value`.
+///
+/// - Parameters:
+///   - handle: The handle to a TensorArray.
+///   - indices: The locations at which to write the tensor elements.
+///   - value: The concatenated tensor to write to the TensorArray.
+///   - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Output flow_out: A float scalar that enforces proper chaining of operations.
+@inlinable @inline(__always)
+public static func tensorArrayScatterV3<T: TensorFlowScalar>(
+  handle: ResourceHandle,
+  indices: Tensor<Int32>,
+  value: Tensor<T>,
+  flowIn: Tensor<Float>
+) -> Tensor<Float> {
+  let op = TFE_Op("TensorArrayScatterV3")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(value)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Deprecated. Use TensorArraySizeV3
+@inlinable @inline(__always)
+public static func tensorArraySizeV2(
+  handle: StringTensor,
+  flowIn: Tensor<Float>
+) -> Tensor<Int32> {
+  let op = TFE_Op("TensorArraySizeV2")
+  let _ = op.addInput(handle)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Get the current size of the TensorArray.
+///
+/// - Parameters:
+///   - handle: The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
+///   - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Output size: The current size of the TensorArray.
+@inlinable @inline(__always)
+public static func tensorArraySizeV3(
+  handle: ResourceHandle,
+  flowIn: Tensor<Float>
+) -> Tensor<Int32> {
+  let op = TFE_Op("TensorArraySizeV3")
+  let _ = op.addInput(handle)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Deprecated. Use TensorArraySplitV3
+@inlinable @inline(__always)
+public static func tensorArraySplitV2<T: TensorFlowScalar>(
+  handle: StringTensor,
+  value: Tensor<T>,
+  lengths: Tensor<Int64>,
+  flowIn: Tensor<Float>
+) -> Tensor<Float> {
+  let op = TFE_Op("TensorArraySplitV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(value)
+  let _ = op.addInput(lengths)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Split the data from the input value into TensorArray elements.
+///
+/// Assuming that `lengths` takes on values
+///
+///   ```(n0, n1, ..., n(T-1))```
+///
+/// and that `value` has shape
+///
+///   ```(n0 + n1 + ... + n(T-1) x d0 x d1 x ...)```,
+///
+/// this splits values into a TensorArray with T tensors.
+///
+/// TensorArray index t will be the subtensor of values with starting position
+///
+///   ```(n0 + n1 + ... + n(t-1), 0, 0, ...)```
+///
+/// and having size
+///
+///   ```nt x d0 x d1 x ...```
+///
+/// - Parameters:
+///   - handle: The handle to a TensorArray.
+///   - value: The concatenated tensor to write to the TensorArray.
+///   - lengths: The vector of lengths, how to split the rows of value into the
+///     TensorArray.
+///   - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Output flow_out: A float scalar that enforces proper chaining of operations.
+@inlinable @inline(__always)
+public static func tensorArraySplitV3<T: TensorFlowScalar>(
+  handle: ResourceHandle,
+  value: Tensor<T>,
+  lengths: Tensor<Int64>,
+  flowIn: Tensor<Float>
+) -> Tensor<Float> {
+  let op = TFE_Op("TensorArraySplitV3")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(value)
+  let _ = op.addInput(lengths)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Deprecated. Use TensorArrayV3
+@inlinable @inline(__always)
+public static func tensorArrayV2(
+  size: Tensor<Int32>,
+  dtype: TensorDataType,
+  elementShape: TensorShape?,
+  dynamicSize: Bool = false,
+  clearAfterRead: Bool = true,
+  tensorArrayName: String
+) -> StringTensor {
+  let op = TFE_Op("TensorArrayV2")
+  op.setAttr("dtype", dtype)
+  op.setAttr("element_shape", elementShape)
+  op.setAttr("dynamic_size", dynamicSize)
+  op.setAttr("clear_after_read", clearAfterRead)
+  op.setAttr("tensor_array_name", tensorArrayName)
+  let _ = op.addInput(size)
+  return op.execute(Int(1))
+}
+
+/// An array of Tensors of given size.
+///
+/// Write data via Write and read via Read or Pack.
+///
+/// - Parameter size: The size of the array.
+///
+/// - Attrs:
+///   - dtype: The type of the elements on the tensor_array.
+///   - element_shape: The expected shape of an element, if known. Used to
+///     validate the shapes of TensorArray elements. If this shape is not
+///     fully specified, gathering zero-size TensorArrays is an error.
+///   - dynamic_size: A boolean that determines whether writes to the TensorArray
+///     are allowed to grow the size.  By default, this is not allowed.
+///   - clear_after_read: If true (default), Tensors in the TensorArray are cleared
+///     after being read.  This disables multiple read semantics but allows early
+///     release of memory.
+///   - identical_element_shapes: If true (default is false), then all
+///     elements in the TensorArray will be expected to have have identical shapes.
+///     This allows certain behaviors, like dynamically checking for
+///     consistent shapes on write, and being able to fill in properly
+///     shaped zero tensors on stack -- even if the element_shape attribute
+///     is not fully defined.
+///   - tensor_array_name: Overrides the name used for the temporary tensor_array
+///     resource. Default value is the name of the 'TensorArray' op (which
+///     is guaranteed unique).
+///
+/// - Outputs:
+///   - handle: The handle to the TensorArray.
+///   - flow: A scalar used to control gradient flow.
+@inlinable @inline(__always)
+public static func tensorArrayV3(
+  size: Tensor<Int32>,
+  dtype: TensorDataType,
+  elementShape: TensorShape?,
+  dynamicSize: Bool = false,
+  clearAfterRead: Bool = true,
+  identicalElementShapes: Bool = false,
+  tensorArrayName: String
+) -> (handle: ResourceHandle, flow: Tensor<Float>) {
+  let op = TFE_Op("TensorArrayV3")
+  op.setAttr("dtype", dtype)
+  op.setAttr("element_shape", elementShape)
+  op.setAttr("dynamic_size", dynamicSize)
+  op.setAttr("clear_after_read", clearAfterRead)
+  op.setAttr("identical_element_shapes", identicalElementShapes)
+  op.setAttr("tensor_array_name", tensorArrayName)
+  let _ = op.addInput(size)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Deprecated. Use TensorArrayGradV3
+@inlinable @inline(__always)
+public static func tensorArrayWriteV2<T: TensorFlowScalar>(
+  handle: StringTensor,
+  index: Tensor<Int32>,
+  value: Tensor<T>,
+  flowIn: Tensor<Float>
+) -> Tensor<Float> {
+  let op = TFE_Op("TensorArrayWriteV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(index)
+  let _ = op.addInput(value)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Push an element onto the tensor_array.
+///
+/// - Parameters:
+///   - handle: The handle to a TensorArray.
+///   - index: The position to write to inside the TensorArray.
+///   - value: The tensor to write to the TensorArray.
+///   - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Output flow_out: A float scalar that enforces proper chaining of operations.
+@inlinable @inline(__always)
+public static func tensorArrayWriteV3<T: TensorFlowScalar>(
+  handle: ResourceHandle,
+  index: Tensor<Int32>,
+  value: Tensor<T>,
+  flowIn: Tensor<Float>
+) -> Tensor<Float> {
+  let op = TFE_Op("TensorArrayWriteV3")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(handle)
+  let _ = op.addInput(index)
+  let _ = op.addInput(value)
+  let _ = op.addInput(flowIn)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that emits `components` as a tuple of tensors once.
+@inlinable @inline(__always)
+public static func tensorDataset<ToutputTypes: TensorArrayProtocol>(
+  components: ToutputTypes,
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("TensorDataset")
+  op.setAttr("Toutput_types", components._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInputList(components)
+  return op.execute(Int(1))
+}
+
+/// Creates a tree resource and returns a handle to it.
+///
+/// - Parameters:
+///   - tree_handle: Handle to the tree resource to be created.
+///   - tree_config: Serialized proto string of the boosted_trees.Tree.
+@inlinable @inline(__always)
+public static func tensorForestCreateTreeVariable(
+  treeHandle: ResourceHandle,
+  treeConfig: StringTensor
+) {
+  let op = TFE_Op("TensorForestCreateTreeVariable")
+  let _ = op.addInput(treeHandle)
+  let _ = op.addInput(treeConfig)
+  op.execute()
+}
+
+/// Deserializes a proto into the tree handle
+///
+/// - Parameters:
+///   - tree_handle: Handle to the tree resource to be restored.
+///   - tree_config: Serialied proto string of the boosted_trees.Tree proto.
+@inlinable @inline(__always)
+public static func tensorForestTreeDeserialize(
+  treeHandle: ResourceHandle,
+  treeConfig: StringTensor
+) {
+  let op = TFE_Op("TensorForestTreeDeserialize")
+  let _ = op.addInput(treeHandle)
+  let _ = op.addInput(treeConfig)
+  op.execute()
+}
+
+/// Checks whether a tree has been initialized.
+///
+/// - Parameter tree_handle: Handle to the tree.
+///
+/// - Output is_initialized: Whether the tree is initialized.
+@inlinable @inline(__always)
+public static func tensorForestTreeIsInitializedOp(
+  treeHandle: ResourceHandle
+) -> Tensor<Bool> {
+  let op = TFE_Op("TensorForestTreeIsInitializedOp")
+  let _ = op.addInput(treeHandle)
+  return op.execute(Int(1))
+}
+
+/// Output the logits for the given input data
+///
+/// - Parameters:
+///   - tree_handle: Handle to the tree resource.
+///   - dense_features: Rank 2 dense features tensor.
+///
+/// - Attr logits_dimension: Scalar, dimension of the logits.
+///
+/// - Output logits: The logits predictions from the tree for each instance in the batch.
+@inlinable @inline(__always)
+public static func tensorForestTreePredict(
+  treeHandle: ResourceHandle,
+  denseFeatures: Tensor<Float>,
+  logitsDimension: Int64
+) -> Tensor<Float> {
+  let op = TFE_Op("TensorForestTreePredict")
+  op.setAttr("logits_dimension", logitsDimension)
+  let _ = op.addInput(treeHandle)
+  let _ = op.addInput(denseFeatures)
+  return op.execute(Int(1))
+}
+
+/// Creates a handle to a TensorForestTreeResource
+@inlinable @inline(__always)
+public static func tensorForestTreeResourceHandleOp(
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("TensorForestTreeResourceHandleOp")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Serializes the tree handle to a proto
+///
+/// - Parameter tree_handle: Handle to the tree resource to be serialized.
+///
+/// - Output tree_config: Serialied proto string of the tree resource.
+@inlinable @inline(__always)
+public static func tensorForestTreeSerialize(
+  treeHandle: ResourceHandle
+) -> StringTensor {
+  let op = TFE_Op("TensorForestTreeSerialize")
+  let _ = op.addInput(treeHandle)
+  return op.execute(Int(1))
+}
+
+/// Get the number of nodes in a tree
+///
+/// - Parameter tree_handle: Handle to the tree resource.
+///
+/// - Output tree_size: The size of the tree.
+@inlinable @inline(__always)
+public static func tensorForestTreeSize(
+  treeHandle: ResourceHandle
+) -> Tensor<Int32> {
+  let op = TFE_Op("TensorForestTreeSize")
+  let _ = op.addInput(treeHandle)
+  return op.execute(Int(1))
+}
+
+/// Concats all tensors in the list along the 0th dimension.
+///
+/// Requires that all tensors have the same shape except the first dimension.
+///
+/// input_handle: The input list.
+/// tensor: The concated result.
+/// lengths: Output tensor containing sizes of the 0th dimension of tensors in the list, used for computing the gradient.
+///
+@inlinable @inline(__always)
+public static func tensorListConcat<ElementDtype: TensorFlowScalar>(
+  inputHandle: VariantHandle,
+  elementShape: TensorShape?
+) -> (tensor: Tensor<ElementDtype>, lengths: Tensor<Int64>) {
+  let op = TFE_Op("TensorListConcat")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  op.setAttr("element_shape", elementShape)
+  let _ = op.addInput(inputHandle)
+  return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func tensorListConcatLists(
+  inputA: VariantHandle,
+  inputB: VariantHandle,
+  elementDtype: TensorDataType
+) -> VariantHandle {
+  let op = TFE_Op("TensorListConcatLists")
+  op.setAttr("element_dtype", elementDtype)
+  let _ = op.addInput(inputA)
+  let _ = op.addInput(inputB)
+  return op.execute(Int(1))
+}
+
+/// Concats all tensors in the list along the 0th dimension.
+///
+/// Requires that all tensors have the same shape except the first dimension.
+///
+/// input_handle: The input list.
+/// element_shape: The shape of the uninitialized elements in the list. If the first
+///   dimension is not -1, it is assumed that all list elements have the same
+///   leading dim.
+/// leading_dims: The list of leading dims of uninitialized list elements. Used if
+///   the leading dim of input_handle.element_shape or the element_shape input arg
+///   is not already set.
+/// tensor: The concated result.
+/// lengths: Output tensor containing sizes of the 0th dimension of tensors in the list, used for computing the gradient.
+///
+@inlinable @inline(__always)
+public static func tensorListConcatV2<
+    ElementDtype: TensorFlowScalar,
+    ShapeType: BinaryInteger & TensorFlowScalar
+>(
+  inputHandle: VariantHandle,
+  elementShape: Tensor<ShapeType>,
+  leadingDims: Tensor<Int64>
+) -> (tensor: Tensor<ElementDtype>, lengths: Tensor<Int64>) {
+  let op = TFE_Op("TensorListConcatV2")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
+  let _ = op.addInput(inputHandle)
+  let _ = op.addInput(elementShape)
+  let _ = op.addInput(leadingDims)
+  return op.execute(Int(1), Int(1))
+}
+
+/// The shape of the elements of the given list, as a tensor.
+///
+///   input_handle: the list
+///   element_shape: the shape of elements of the list
+@inlinable @inline(__always)
+public static func tensorListElementShape<ShapeType: BinaryInteger & TensorFlowScalar>(
+  inputHandle: VariantHandle
+) -> Tensor<ShapeType> {
+  let op = TFE_Op("TensorListElementShape")
+  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
+  let _ = op.addInput(inputHandle)
+  return op.execute(Int(1))
+}
+
+/// Creates a TensorList which, when stacked, has the value of `tensor`.
+///
+/// Each tensor in the result list corresponds to one row of the input tensor.
+///
+/// tensor: The input tensor.
+/// output_handle: The list.
+@inlinable @inline(__always)
+public static func tensorListFromTensor<
+    ElementDtype: TensorFlowScalar,
+    ShapeType: BinaryInteger & TensorFlowScalar
+>(
+  _ tensor: Tensor<ElementDtype>,
+  elementShape: Tensor<ShapeType>
+) -> VariantHandle {
+  let op = TFE_Op("TensorListFromTensor")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(elementShape)
+  return op.execute(Int(1))
+}
+
+/// Creates a Tensor by indexing into the TensorList.
+///
+/// Each row in the produced Tensor corresponds to the element in the TensorList
+/// specified by the given index (see `tf.gather`).  
+///
+/// input_handle: The input tensor list.
+/// indices: The indices used to index into the list.
+/// values: The tensor.
+@inlinable @inline(__always)
+public static func tensorListGather<ElementDtype: TensorFlowScalar>(
+  inputHandle: VariantHandle,
+  indices: Tensor<Int32>,
+  elementShape: Tensor<Int32>
+) -> Tensor<ElementDtype> {
+  let op = TFE_Op("TensorListGather")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  let _ = op.addInput(inputHandle)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(elementShape)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func tensorListGetItem<ElementDtype: TensorFlowScalar>(
+  inputHandle: VariantHandle,
+  index: Tensor<Int32>,
+  elementShape: Tensor<Int32>
+) -> Tensor<ElementDtype> {
+  let op = TFE_Op("TensorListGetItem")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  let _ = op.addInput(inputHandle)
+  let _ = op.addInput(index)
+  let _ = op.addInput(elementShape)
+  return op.execute(Int(1))
+}
+
+/// Returns the number of tensors in the input tensor list.
+///
+/// input_handle: the input list
+/// length: the number of tensors in the list
+@inlinable @inline(__always)
+public static func tensorListLength(
+  inputHandle: VariantHandle
+) -> Tensor<Int32> {
+  let op = TFE_Op("TensorListLength")
+  let _ = op.addInput(inputHandle)
+  return op.execute(Int(1))
+}
+
+/// Returns the last element of the input list as well as a list with all but that element.
+///
+/// Fails if the list is empty.
+///
+/// input_handle: the input list
+/// tensor: the withdrawn last element of the list
+/// element_dtype: the type of elements in the list
+/// element_shape: the shape of the output tensor
+@inlinable @inline(__always)
+public static func tensorListPopBack<ElementDtype: TensorFlowScalar>(
+  inputHandle: VariantHandle,
+  elementShape: Tensor<Int32>
+) -> (outputHandle: VariantHandle, tensor: Tensor<ElementDtype>) {
+  let op = TFE_Op("TensorListPopBack")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  let _ = op.addInput(inputHandle)
+  let _ = op.addInput(elementShape)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Returns a list list which has the passed-in `Tensor` as last element and the other elements of the given list in `input_handle`.
+///
+/// tensor: The tensor to put on the list.
+/// input_handle: The old list.
+/// output_handle: A list with the elements of the old list followed by tensor.
+/// element_dtype: the type of elements in the list.
+/// element_shape: a shape compatible with that of elements in the list.
+@inlinable @inline(__always)
+public static func tensorListPushBack<ElementDtype: TensorFlowScalar>(
+  inputHandle: VariantHandle,
+  _ tensor: Tensor<ElementDtype>
+) -> VariantHandle {
+  let op = TFE_Op("TensorListPushBack")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  let _ = op.addInput(inputHandle)
+  let _ = op.addInput(tensor)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func tensorListPushBackBatch<ElementDtype: TensorFlowScalar>(
+  inputHandles: VariantHandle,
+  _ tensor: Tensor<ElementDtype>
+) -> VariantHandle {
+  let op = TFE_Op("TensorListPushBackBatch")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  let _ = op.addInput(inputHandles)
+  let _ = op.addInput(tensor)
+  return op.execute(Int(1))
+}
+
+/// List of the given size with empty elements.
+///
+/// element_shape: the shape of the future elements of the list
+/// num_elements: the number of elements to reserve
+/// handle: the output list
+/// element_dtype: the desired type of elements in the list.
+@inlinable @inline(__always)
+public static func tensorListReserve<ShapeType: BinaryInteger & TensorFlowScalar>(
+  elementShape: Tensor<ShapeType>,
+  numElements: Tensor<Int32>,
+  elementDtype: TensorDataType
+) -> VariantHandle {
+  let op = TFE_Op("TensorListReserve")
+  op.setAttr("element_dtype", elementDtype)
+  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
+  let _ = op.addInput(elementShape)
+  let _ = op.addInput(numElements)
+  return op.execute(Int(1))
+}
+
+/// Resizes the list.
+///
+///
+/// input_handle: the input list
+/// size: size of the output list
+///
+@inlinable @inline(__always)
+public static func tensorListResize(
+  inputHandle: VariantHandle,
+  size: Tensor<Int32>
+) -> VariantHandle {
+  let op = TFE_Op("TensorListResize")
+  let _ = op.addInput(inputHandle)
+  let _ = op.addInput(size)
+  return op.execute(Int(1))
+}
+
+/// Creates a TensorList by indexing into a Tensor.
+///
+/// Each member of the TensorList corresponds to one row of the input tensor,
+/// specified by the given index (see `tf.gather`).
+///
+/// tensor: The input tensor.
+/// indices: The indices used to index into the list.
+/// element_shape: The shape of the elements in the list (can be less specified than
+///   the shape of the tensor).  
+/// output_handle: The TensorList.
+@inlinable @inline(__always)
+public static func tensorListScatter<
+    ElementDtype: TensorFlowScalar,
+    ShapeType: BinaryInteger & TensorFlowScalar
+>(
+  _ tensor: Tensor<ElementDtype>,
+  indices: Tensor<Int32>,
+  elementShape: Tensor<ShapeType>
+) -> VariantHandle {
+  let op = TFE_Op("TensorListScatter")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(elementShape)
+  return op.execute(Int(1))
+}
+
+/// Scatters tensor at indices in an input list.
+///
+/// Each member of the TensorList corresponds to one row of the input tensor,
+/// specified by the given index (see `tf.gather`).
+///
+/// input_handle: The list to scatter into.
+/// tensor: The input tensor.
+/// indices: The indices used to index into the list.
+/// output_handle: The TensorList.
+@inlinable @inline(__always)
+public static func tensorListScatterIntoExistingList<ElementDtype: TensorFlowScalar>(
+  inputHandle: VariantHandle,
+  _ tensor: Tensor<ElementDtype>,
+  indices: Tensor<Int32>
+) -> VariantHandle {
+  let op = TFE_Op("TensorListScatterIntoExistingList")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  let _ = op.addInput(inputHandle)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(indices)
+  return op.execute(Int(1))
+}
+
+/// Creates a TensorList by indexing into a Tensor.
+///
+/// Each member of the TensorList corresponds to one row of the input tensor,
+/// specified by the given index (see `tf.gather`).
+///
+/// tensor: The input tensor.
+/// indices: The indices used to index into the list.
+/// element_shape: The shape of the elements in the list (can be less specified than
+///   the shape of the tensor).
+/// num_elements: The size of the output list. Must be large enough to accommodate
+///   the largest index in indices. If -1, the list is just large enough to include
+///   the largest index in indices.
+/// output_handle: The TensorList.
+@inlinable @inline(__always)
+public static func tensorListScatterV2<
+    ElementDtype: TensorFlowScalar,
+    ShapeType: BinaryInteger & TensorFlowScalar
+>(
+  _ tensor: Tensor<ElementDtype>,
+  indices: Tensor<Int32>,
+  elementShape: Tensor<ShapeType>,
+  numElements: Tensor<Int32>
+) -> VariantHandle {
+  let op = TFE_Op("TensorListScatterV2")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(elementShape)
+  let _ = op.addInput(numElements)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func tensorListSetItem<ElementDtype: TensorFlowScalar>(
+  inputHandle: VariantHandle,
+  index: Tensor<Int32>,
+  item: Tensor<ElementDtype>
+) -> VariantHandle {
+  let op = TFE_Op("TensorListSetItem")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  let _ = op.addInput(inputHandle)
+  let _ = op.addInput(index)
+  let _ = op.addInput(item)
+  return op.execute(Int(1))
+}
+
+/// Splits a tensor into a list.
+///
+/// list[i] corresponds to lengths[i] tensors from the input tensor.
+/// The tensor must have rank at least 1 and contain exactly sum(lengths) elements.
+///
+/// tensor: The input tensor.
+/// element_shape: A shape compatible with that of elements in the tensor.
+/// lengths: Vector of sizes of the 0th dimension of tensors in the list.
+/// output_handle: The list.
+@inlinable @inline(__always)
+public static func tensorListSplit<
+    ElementDtype: TensorFlowScalar,
+    ShapeType: BinaryInteger & TensorFlowScalar
+>(
+  _ tensor: Tensor<ElementDtype>,
+  elementShape: Tensor<ShapeType>,
+  lengths: Tensor<Int64>
+) -> VariantHandle {
+  let op = TFE_Op("TensorListSplit")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(elementShape)
+  let _ = op.addInput(lengths)
+  return op.execute(Int(1))
+}
+
+/// Stacks all tensors in the list.
+///
+/// Requires that all tensors have the same shape.
+///
+/// input_handle: the input list
+/// tensor: the gathered result
+/// num_elements: optional. If not -1, the number of elements in the list.
+///
+@inlinable @inline(__always)
+public static func tensorListStack<ElementDtype: TensorFlowScalar>(
+  inputHandle: VariantHandle,
+  elementShape: Tensor<Int32>,
+  numElements: Int64 = -1
+) -> Tensor<ElementDtype> {
+  let op = TFE_Op("TensorListStack")
+  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
+  op.setAttr("num_elements", numElements)
+  let _ = op.addInput(inputHandle)
+  let _ = op.addInput(elementShape)
+  return op.execute(Int(1))
+}
+
+/// Adds sparse `updates` to an existing tensor according to `indices`.
+///
+/// This operation creates a new tensor by adding sparse `updates` to the passed
+/// in `tensor`.
+/// This operation is very similar to `tf.scatter_nd_add`, except that the updates
+/// are added onto an existing tensor (as opposed to a variable). If the memory
+/// for the existing tensor cannot be re-used, a copy is made and updated.
+///
+/// `indices` is an integer tensor containing indices into a new tensor of shape
+/// `shape`.  The last dimension of `indices` can be at most the rank of `shape`:
+///
+///     indices.shape[-1] <= shape.rank
+///
+/// The last dimension of `indices` corresponds to indices into elements
+/// (if `indices.shape[-1] = shape.rank`) or slices
+/// (if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
+/// `shape`.  `updates` is a tensor with shape
+///
+///     indices.shape[:-1] + shape[indices.shape[-1]:]
+///
+/// The simplest form of tensor_scatter_add is to add individual elements to a
+/// tensor by index. For example, say we want to add 4 elements in a rank-1
+/// tensor with 8 elements.
+///
+/// In Python, this scatter add operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[4], [3], [1], [7]])
+///     updates = tf.constant([9, 10, 11, 12])
+///     tensor = tf.ones([8], dtype=tf.int32)
+///     updated = tf.tensor_scatter_add(tensor, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [1, 12, 1, 11, 10, 1, 1, 13]
+///
+/// We can also, insert entire slices of a higher rank tensor all at once. For
+/// example, if we wanted to insert two slices in the first dimension of a
+/// rank-3 tensor with two matrices of new values.
+///
+/// In Python, this scatter add operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[0], [2]])
+///     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]],
+///                            [[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]]])
+///     tensor = tf.ones([4, 4, 4])
+///     updated = tf.tensor_scatter_add(tensor, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [[[6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8], [9, 9, 9, 9]],
+///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
+///      [[6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8], [9, 9, 9, 9]],
+///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+///
+/// Note that on CPU, if an out of bound index is found, an error is returned.
+/// On GPU, if an out of bound index is found, the index is ignored.
+///
+/// - Parameters:
+///   - tensor: Tensor to copy/update.
+///   - indices: Index tensor.
+///   - updates: Updates to scatter into output.
+///
+/// - Output output: A new tensor copied from tensor and updates added according to the indices.
+@inlinable @inline(__always)
+public static func tensorScatterAdd<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  _ tensor: Tensor<T>,
+  indices: Tensor<Tindices>,
+  updates: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("TensorScatterAdd")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  return op.execute(Int(1))
+}
+
+/// Subtracts sparse `updates` from an existing tensor according to `indices`.
+///
+/// This operation creates a new tensor by subtracting sparse `updates` from the
+/// passed in `tensor`.
+/// This operation is very similar to `tf.scatter_nd_sub`, except that the updates
+/// are subtracted from an existing tensor (as opposed to a variable). If the memory
+/// for the existing tensor cannot be re-used, a copy is made and updated.
+///
+/// `indices` is an integer tensor containing indices into a new tensor of shape
+/// `shape`.  The last dimension of `indices` can be at most the rank of `shape`:
+///
+///     indices.shape[-1] <= shape.rank
+///
+/// The last dimension of `indices` corresponds to indices into elements
+/// (if `indices.shape[-1] = shape.rank`) or slices
+/// (if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
+/// `shape`.  `updates` is a tensor with shape
+///
+///     indices.shape[:-1] + shape[indices.shape[-1]:]
+///
+/// The simplest form of tensor_scatter_sub is to subtract individual elements
+/// from a tensor by index. For example, say we want to insert 4 scattered elements
+/// in a rank-1 tensor with 8 elements.
+///
+/// In Python, this scatter subtract operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[4], [3], [1], [7]])
+///     updates = tf.constant([9, 10, 11, 12])
+///     tensor = tf.ones([8], dtype=tf.int32)
+///     updated = tf.tensor_scatter_sub(tensor, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [1, -10, 1, -9, -8, 1, 1, -11]
+///
+/// We can also, insert entire slices of a higher rank tensor all at once. For
+/// example, if we wanted to insert two slices in the first dimension of a
+/// rank-3 tensor with two matrices of new values.
+///
+/// In Python, this scatter add operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[0], [2]])
+///     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]],
+///                            [[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]]])
+///     tensor = tf.ones([4, 4, 4])
+///     updated = tf.tensor_scatter_sub(tensor, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [[[-4, -4, -4, -4], [-5, -5, -5, -5], [-6, -6, -6, -6], [-7, -7, -7, -7]],
+///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
+///      [[-4, -4, -4, -4], [-5, -5, -5, -5], [-6, -6, -6, -6], [-7, -7, -7, -7]],
+///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+///
+/// Note that on CPU, if an out of bound index is found, an error is returned.
+/// On GPU, if an out of bound index is found, the index is ignored.
+///
+/// - Parameters:
+///   - tensor: Tensor to copy/update.
+///   - indices: Index tensor.
+///   - updates: Updates to scatter into output.
+///
+/// - Output output: A new tensor copied from tensor and updates subtracted according to the indices.
+@inlinable @inline(__always)
+public static func tensorScatterSub<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  _ tensor: Tensor<T>,
+  indices: Tensor<Tindices>,
+  updates: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("TensorScatterSub")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  return op.execute(Int(1))
+}
+
+/// Scatter `updates` into an existing tensor according to `indices`.
+///
+/// This operation creates a new tensor by applying sparse `updates` to the passed
+/// in `tensor`.
+/// This operation is very similar to `tf.scatter_nd`, except that the updates are
+/// scattered onto an existing tensor (as opposed to a zero-tensor). If the memory
+/// for the existing tensor cannot be re-used, a copy is made and updated.
+///
+/// If `indices` contains duplicates, then their updates are accumulated (summed).
+///
+/// **WARNING**: The order in which updates are applied is nondeterministic, so the
+/// output will be nondeterministic if `indices` contains duplicates -- because
+/// of some numerical approximation issues, numbers summed in different order
+/// may yield different results.
+///
+/// `indices` is an integer tensor containing indices into a new tensor of shape
+/// `shape`.  The last dimension of `indices` can be at most the rank of `shape`:
+///
+///     indices.shape[-1] <= shape.rank
+///
+/// The last dimension of `indices` corresponds to indices into elements
+/// (if `indices.shape[-1] = shape.rank`) or slices
+/// (if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
+/// `shape`.  `updates` is a tensor with shape
+///
+///     indices.shape[:-1] + shape[indices.shape[-1]:]
+///
+/// The simplest form of scatter is to insert individual elements in a tensor by
+/// index. For example, say we want to insert 4 scattered elements in a rank-1
+/// tensor with 8 elements.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd1.png" alt>
+/// </div>
+///
+/// In Python, this scatter operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[4], [3], [1], [7]])
+///     updates = tf.constant([9, 10, 11, 12])
+///     tensor = tf.ones([8], dtype=tf.int32)
+///     updated = tf.tensor_scatter_update(tensor, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [1, 11, 1, 10, 9, 1, 1, 12]
+///
+/// We can also, insert entire slices of a higher rank tensor all at once. For
+/// example, if we wanted to insert two slices in the first dimension of a
+/// rank-3 tensor with two matrices of new values.
+///
+/// In Python, this scatter operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[0], [2]])
+///     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]],
+///                            [[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]]])
+///     tensor = tf.ones([4, 4, 4])
+///     updated = tf.tensor_scatter_update(tensor, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
+///      [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+///
+/// Note that on CPU, if an out of bound index is found, an error is returned.
+/// On GPU, if an out of bound index is found, the index is ignored.
+///
+/// - Parameters:
+///   - tensor: Tensor to copy/update.
+///   - indices: Index tensor.
+///   - updates: Updates to scatter into output.
+///
+/// - Output output: A new tensor with the given shape and updates applied according
+///   to the indices.
+@inlinable @inline(__always)
+public static func tensorScatterUpdate<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+  _ tensor: Tensor<T>,
+  indices: Tensor<Tindices>,
+  updates: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("TensorScatterUpdate")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(updates)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that emits each dim-0 slice of `components` once.
+@inlinable @inline(__always)
+public static func tensorSliceDataset<ToutputTypes: TensorArrayProtocol>(
+  components: ToutputTypes,
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("TensorSliceDataset")
+  op.setAttr("Toutput_types", components._typeList)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInputList(components)
+  return op.execute(Int(1))
+}
+
+/// Assign `value` to the sliced l-value reference of `input`.
+///
+/// The values of `value` are assigned to the positions in the tensor `input` that
+/// are selected by the slice parameters. The slice parameters `begin` `end`
+/// `strides` etc. work exactly as in `StridedSlice`.
+///
+/// NOTE this op currently does not support broadcasting and so `value`'s shape
+/// must be exactly the shape produced by the slice of `input`.
+@inlinable @inline(__always)
+public static func tensorStridedSliceUpdate<
+    T: TensorFlowScalar,
+    Index: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  begin: Tensor<Index>,
+  end: Tensor<Index>,
+  strides: Tensor<Index>,
+  value: Tensor<T>,
+  beginMask: Int64 = 0,
+  endMask: Int64 = 0,
+  ellipsisMask: Int64 = 0,
+  newAxisMask: Int64 = 0,
+  shrinkAxisMask: Int64 = 0
+) -> Tensor<T> {
+  let op = TFE_Op("TensorStridedSliceUpdate")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Index", Index.tensorFlowDataType)
+  op.setAttr("begin_mask", beginMask)
+  op.setAttr("end_mask", endMask)
+  op.setAttr("ellipsis_mask", ellipsisMask)
+  op.setAttr("new_axis_mask", newAxisMask)
+  op.setAttr("shrink_axis_mask", shrinkAxisMask)
+  let _ = op.addInput(input)
+  let _ = op.addInput(begin)
+  let _ = op.addInput(end)
+  let _ = op.addInput(strides)
+  let _ = op.addInput(value)
+  return op.execute(Int(1))
+}
+
+/// Outputs a `Summary` protocol buffer with a tensor.
+///
+/// This op is being phased out in favor of TensorSummaryV2, which lets callers pass
+/// a tag as well as a serialized SummaryMetadata proto string that contains
+/// plugin-specific data. We will keep this op to maintain backwards compatibility.
+///
+/// - Parameter tensor: A tensor to serialize.
+///
+/// - Attrs:
+///   - description: A json-encoded SummaryDescription proto.
+///   - labels: An unused list of strings.
+///   - display_name: An unused string.
+@inlinable @inline(__always)
+public static func tensorSummary<T: TensorFlowScalar>(
+  _ tensor: Tensor<T>,
+  description: String,
+  labels: [String],
+  displayName: String
+) -> StringTensor {
+  let op = TFE_Op("TensorSummary")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("description", description)
+  op.setAttr("labels", labels)
+  op.setAttr("display_name", displayName)
+  let _ = op.addInput(tensor)
+  return op.execute(Int(1))
+}
+
+/// Outputs a `Summary` protocol buffer with a tensor and per-plugin data.
+///
+/// - Parameters:
+///   - tag: A string attached to this summary. Used for organization in TensorBoard.
+///   - tensor: A tensor to serialize.
+///   - serialized_summary_metadata: A serialized SummaryMetadata proto. Contains plugin
+///     data.
+@inlinable @inline(__always)
+public static func tensorSummaryV2<T: TensorFlowScalar>(
+  tag: StringTensor,
+  _ tensor: Tensor<T>,
+  serializedSummaryMetadata: StringTensor
+) -> StringTensor {
+  let op = TFE_Op("TensorSummaryV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(tag)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(serializedSummaryMetadata)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func testAttr<T: FloatingPoint & TensorFlowScalar>(
+) -> Tensor<T> {
+  let op = TFE_Op("TestAttr")
+  op.setAttr("T", T.tensorFlowDataType)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func testStringOutput(
+  _ input: Tensor<Float>
+) -> (output1: Tensor<Float>, output2: StringTensor) {
+  let op = TFE_Op("TestStringOutput")
+  let _ = op.addInput(input)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Creates a dataset that emits the lines of one or more text files.
+///
+/// - Parameters:
+///   - filenames: A scalar or a vector containing the name(s) of the file(s) to be
+///     read.
+///   - compression_type: A scalar containing either (i) the empty string (no
+///     compression), (ii) "ZLIB", or (iii) "GZIP".
+///   - buffer_size: A scalar containing the number of bytes to buffer.
+@inlinable @inline(__always)
+public static func textLineDataset(
+  filenames: StringTensor,
+  compressionType: StringTensor,
+  bufferSize: Tensor<Int64>
+) -> VariantHandle {
+  let op = TFE_Op("TextLineDataset")
+  let _ = op.addInput(filenames)
+  let _ = op.addInput(compressionType)
+  let _ = op.addInput(bufferSize)
+  return op.execute(Int(1))
+}
+
+/// A Reader that outputs the lines of a file delimited by '\n'.
+///
+/// - Attrs:
+///   - skip_header_lines: Number of lines to skip from the beginning of every file.
+///   - container: If non-empty, this reader is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this reader is named in the given bucket
+///     with this shared_name. Otherwise, the node name is used instead.
+///
+/// - Output reader_handle: The handle to reference the Reader.
+@inlinable @inline(__always)
+public static func textLineReaderV2(
+  skipHeaderLines: Int64 = 0,
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("TextLineReaderV2")
+  op.setAttr("skip_header_lines", skipHeaderLines)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// Generates labels for candidate sampling with a learned unigram distribution.
+///
+/// See explanations of candidate sampling and the data formats at
+/// go/candidate-sampling.
+///
+/// For each batch, this op picks a single set of sampled candidate labels.
+///
+/// The advantages of sampling candidates per-batch are simplicity and the
+/// possibility of efficient dense matrix multiplication. The disadvantage is that
+/// the sampled candidates must be chosen independently of the context and of the
+/// true labels.
+///
+/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
+///   IDs of the num_true target_classes in the corresponding original label.
+///
+/// - Attrs:
+///   - num_true: Number of true labels per context.
+///   - num_sampled: Number of candidates to randomly sample.
+///   - unique: If unique is true, we sample with rejection, so that all sampled
+///     candidates in a batch are unique. This requires some approximation to
+///     estimate the post-rejection sampling probabilities.
+///   - range_max: The sampler will sample integers from the interval [0, range_max).
+///   - seed: If either seed or seed2 are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///   - sampled_candidates: A vector of length num_sampled, in which each element is
+///     the ID of a sampled candidate.
+///   - true_expected_count: A batch_size * num_true matrix, representing
+///     the number of times each candidate is expected to occur in a batch
+///     of sampled candidates. If unique=true, then this is a probability.
+///   - sampled_expected_count: A vector of length num_sampled, for each sampled
+///     candidate representing the number of times the candidate is expected
+///     to occur in a batch of sampled candidates.  If unique=true, then this is a
+///     probability.
+@inlinable @inline(__always)
+public static func threadUnsafeUnigramCandidateSampler(
+  trueClasses: Tensor<Int64>,
+  numTrue: Int64,
+  numSampled: Int64,
+  unique: Bool,
+  rangeMax: Int64,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
+  let op = TFE_Op("ThreadUnsafeUnigramCandidateSampler")
+  op.setAttr("num_true", numTrue)
+  op.setAttr("num_sampled", numSampled)
+  op.setAttr("unique", unique)
+  op.setAttr("range_max", rangeMax)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(trueClasses)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Constructs a tensor by tiling a given tensor.
+///
+/// This operation creates a new tensor by replicating `input` `multiples` times.
+/// The output tensor's i'th dimension has `input.dims(i) * multiples[i]` elements,
+/// and the values of `input` are replicated `multiples[i]` times along the 'i'th
+/// dimension. For example, tiling `[a b c d]` by `[2]` produces
+/// `[a b c d a b c d]`.
+///
+/// - Parameters:
+///   - input: 1-D or higher.
+///   - multiples: 1-D. Length must be the same as the number of dimensions in `input`
+@inlinable @inline(__always)
+public static func tile<
+    T: TensorFlowScalar,
+    Tmultiples: BinaryInteger & TensorFlowScalar
+>(
+  _ input: Tensor<T>,
+  multiples: Tensor<Tmultiples>
+) -> Tensor<T> {
+  let op = TFE_Op("Tile")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tmultiples", Tmultiples.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(multiples)
+  return op.execute(Int(1))
+}
+
+/// Returns the gradient of `Tile`.
+///
+/// Since `Tile` takes an input and repeats the input `multiples` times
+/// along each dimension, `TileGrad` takes in `multiples` and aggregates
+/// each repeated tile of `input` into `output`.
+@inlinable @inline(__always)
+public static func tileGrad<T: TensorFlowScalar>(
+  _ input: Tensor<T>,
+  multiples: Tensor<Int32>
+) -> Tensor<T> {
+  let op = TFE_Op("TileGrad")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(multiples)
+  return op.execute(Int(1))
+}
+
+/// Provides the time since epoch in seconds.
+///
+/// Returns the timestamp as a `float64` for seconds since the Unix epoch.
+///
+/// Note: the timestamp is computed when the op is executed, not when it is added
+/// to the graph.
+@inlinable @inline(__always)
+public static func timestamp(
+) -> Tensor<Double> {
+  let op = TFE_Op("Timestamp")
+  
+  return op.execute(Int(1))
+}
+
+/// Finds values and indices of the `k` largest elements for the last dimension.
+///
+/// If the input is a vector (rank-1), finds the `k` largest entries in the vector
+/// and outputs their values and indices as vectors.  Thus `values[j]` is the
+/// `j`-th largest entry in `input`, and its index is `indices[j]`.
+///
+/// For matrices (resp. higher rank input), computes the top `k` entries in each
+/// row (resp. vector along the last dimension).  Thus,
+///
+///     values.shape = indices.shape = input.shape[:-1] + [k]
+///
+/// If two elements are equal, the lower-index element appears first.
+///
+/// If `k` varies dynamically, use `TopKV2` below.
+///
+/// - Parameter input: 1-D or higher with last dimension at least `k`.
+///
+/// - Attrs:
+///   - k: Number of top elements to look for along the last dimension (along each
+///     row for matrices).
+///   - sorted: If true the resulting `k` elements will be sorted by the values in
+///     descending order.
+///
+/// - Outputs:
+///   - values: The `k` largest elements along each last dimensional slice.
+///   - indices: The indices of `values` within the last dimension of `input`.
+@inlinable @inline(__always)
+public static func topK<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  k: Int64,
+  sorted: Bool = true
+) -> (values: Tensor<T>, indices: Tensor<Int32>) {
+  let op = TFE_Op("TopK")
+  op.setAttr("k", k)
+  op.setAttr("sorted", sorted)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Finds values and indices of the `k` largest elements for the last dimension.
+///
+/// If the input is a vector (rank-1), finds the `k` largest entries in the vector
+/// and outputs their values and indices as vectors.  Thus `values[j]` is the
+/// `j`-th largest entry in `input`, and its index is `indices[j]`.
+///
+/// For matrices (resp. higher rank input), computes the top `k` entries in each
+/// row (resp. vector along the last dimension).  Thus,
+///
+///     values.shape = indices.shape = input.shape[:-1] + [k]
+///
+/// If two elements are equal, the lower-index element appears first.
+///
+/// - Parameters:
+///   - input: 1-D or higher with last dimension at least `k`.
+///   - k: 0-D.  Number of top elements to look for along the last dimension (along each
+///     row for matrices).
+///
+/// - Attr sorted: If true the resulting `k` elements will be sorted by the values in
+///   descending order.
+///
+/// - Outputs:
+///   - values: The `k` largest elements along each last dimensional slice.
+///   - indices: The indices of `values` within the last dimension of `input`.
+@inlinable @inline(__always)
+public static func topKV2<T: Numeric & TensorFlowScalar>(
+  _ input: Tensor<T>,
+  k: Tensor<Int32>,
+  sorted: Bool = true
+) -> (values: Tensor<T>, indices: Tensor<Int32>) {
+  let op = TFE_Op("TopKV2")
+  op.setAttr("sorted", sorted)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  let _ = op.addInput(k)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Shuffle dimensions of x according to a permutation.
+///
+/// The output `y` has the same rank as `x`. The shapes of `x` and `y` satisfy:
+///   `y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]`
+@inlinable @inline(__always)
+public static func transpose<
+    T: TensorFlowScalar,
+    Tperm: BinaryInteger & TensorFlowScalar
+>(
+  _ x: Tensor<T>,
+  perm: Tensor<Tperm>
+) -> Tensor<T> {
+  let op = TFE_Op("Transpose")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tperm", Tperm.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(perm)
+  return op.execute(Int(1))
+}
+
+/// Solves tridiagonal systems of equations.
+///
+/// `diagonals` is a tensor of shape `[..., 3, M]` whose inner-most 2 dimensions
+/// represent matrices with three rows being the superdiagonal, diagonals, and
+/// subdiagonals, in order. The last element of the superdiagonal and the first
+/// element of the subdiagonal is ignored.
+/// `rhs` is a tensor of shape `[..., M, K]`, representing K right-hand sides per
+/// each left-hand side.
+/// The output is a tensor of shape `[..., M, K]` containing the solutions.
+///
+/// - Parameters:
+///   - diagonals: Shape is `[..., 3, M]`.
+///   - rhs: Shape is `[..., M, K]`.
+///
+/// - Output output: Shape is `[..., M, K]`.
+@inlinable @inline(__always)
+public static func tridiagonalSolve<T: FloatingPoint & TensorFlowScalar>(
+  diagonals: Tensor<T>,
+  rhs: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("TridiagonalSolve")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(diagonals)
+  let _ = op.addInput(rhs)
+  return op.execute(Int(1))
+}
+
+/// Returns x / y element-wise for integer types.
+///
+/// Truncation designates that negative numbers will round fractional quantities
+/// toward zero. I.e. -7 / 5 = -1. This matches C semantics but it is different
+/// than Python semantics. See `FloorDiv` for a division function that matches
+/// Python Semantics.
+///
+/// *NOTE*: `TruncateDiv` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func truncateDiv<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("TruncateDiv")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns element-wise remainder of division. This emulates C semantics in that
+///
+/// the result here is consistent with a truncating divide. E.g. `truncate(x / y) *
+/// y + truncate_mod(x, y) = x`.
+///
+/// *NOTE*: `TruncateMod` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func truncateMod<T: Numeric & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("TruncateMod")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Outputs random values from a truncated normal distribution.
+///
+/// The generated values follow a normal distribution with mean 0 and standard
+/// deviation 1, except that values whose magnitude is more than 2 standard
+/// deviations from the mean are dropped and re-picked.
+///
+/// - Parameter shape: The shape of the output tensor.
+///
+/// - Attrs:
+///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: A second seed to avoid seed collision.
+///   - dtype: The type of the output.
+///
+/// - Output output: A tensor of the specified shape filled with random truncated normal
+///   values.
+@inlinable @inline(__always)
+public static func truncatedNormal<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar
+>(
+  shape: Tensor<T>,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> Tensor<Dtype> {
+  let op = TFE_Op("TruncatedNormal")
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  op.setAttr("dtype", Dtype.tensorFlowDataType)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(shape)
+  return op.execute(Int(1))
+}
+
+/// Perform batches of RPC requests.
+///
+/// This op asynchronously performs either a single RPC request, or a batch
+/// of requests.  RPC requests are defined by three main parameters:
+///
+///   - `address` (the host+port or BNS address of the request)
+///   - `method` (the method name for the request)
+///   - `request` (the serialized proto string, or vector of strings,
+///      of the RPC request argument).
+///
+/// For example, if you have an RPC service running on port localhost:2345,
+/// and its interface is configured with the following proto declaration:
+///
+/// ```
+/// service MyService {
+///   rpc MyMethod(MyRequestProto) returns (MyResponseProto) {
+///   }
+/// };
+/// ```
+///
+/// then call this op with arguments:
+///
+/// ```
+/// address = "localhost:2345"
+/// method = "MyService/MyMethod"
+/// ```
+///
+/// The `request` tensor is a string tensor representing serialized `MyRequestProto`
+/// strings; and the output string tensor `response` will have the same shape
+/// and contain (upon successful completion) corresponding serialized
+/// `MyResponseProto` strings.
+///
+/// For example, to send a single, empty, `MyRequestProto`, call
+/// this op with `request = ""`.  To send 5 **parallel** empty requests,
+/// call this op with `request = ["", "", "", "", ""]`.
+///
+/// More generally, one can create a batch of `MyRequestProto` serialized protos
+/// from regular batched tensors using the `encode_proto` op, and convert
+/// the response `MyResponseProto` serialized protos to batched tensors
+/// using the `decode_proto` op.
+///
+/// **NOTE** Working with serialized proto strings is faster than instantiating
+/// actual proto objects in memory, so no performance degradation is expected
+/// compared to writing custom kernels for this workflow.
+///
+/// Unlike the standard `Rpc` op, if the connection fails or the remote worker
+/// returns an error status, this op does **not** reraise the exception.
+/// Instead, the `status_code` and `status_message` entry for the corresponding RPC
+/// call is set with the error returned from the RPC call.  The `response` tensor
+/// will contain valid response values for those minibatch entries whose RPCs did
+/// not fail; the rest of the entries will have empty strings.
+///
+/// - Parameters:
+///   - address: `0-D` or `1-D`.  The address (i.e. host_name:port) of the RPC server.
+///     If this tensor has more than 1 element, then multiple parallel rpc requests
+///     are sent.  This argument broadcasts with `method` and `request`.
+///   - method: `0-D` or `1-D`.  The method address on the RPC server.
+///     If this tensor has more than 1 element, then multiple parallel rpc requests
+///     are sent.  This argument broadcasts with `address` and `request`.
+///   - request: `0-D` or `1-D`.  Serialized proto strings: the rpc request argument.
+///     If this tensor has more than 1 element, then multiple parallel rpc requests
+///     are sent.  This argument broadcasts with `address` and `method`.
+///
+/// - Attrs:
+///   - protocol: RPC protocol to use.  Empty string means use the default protocol.
+///     Options include 'grpc'.
+///   - fail_fast: `boolean`. If `true` (default), then failures to connect
+///     (i.e., the server does not immediately respond) cause an RPC failure.
+///   - timeout_in_ms: `int`. If `0` (default), then the kernel will run the RPC
+///     request and only time out if the RPC deadline passes or the session times out.
+///     If this value is greater than `0`, then the op will raise an exception if
+///     the RPC takes longer than `timeout_in_ms`.
+///
+/// - Outputs:
+///   - response: Same shape as `request`. Serialized proto strings: the rpc responses.
+///   - status_code: Same shape as `request`.  Values correspond to tensorflow Status enum codes.
+///   - status_message: Same shape as `request`.  Values correspond to Status messages
+///     returned from the RPC calls.
+@inlinable @inline(__always)
+public static func tryRpc(
+  address: StringTensor,
+  method: StringTensor,
+  request: StringTensor,
+  protocol_: String,
+  failFast: Bool = true,
+  timeoutInMs: Int64 = 0
+) -> (response: StringTensor, statusCode: Tensor<Int32>, statusMessage: StringTensor) {
+  let op = TFE_Op("TryRpc")
+  op.setAttr("protocol", protocol_)
+  op.setAttr("fail_fast", failFast)
+  op.setAttr("timeout_in_ms", timeoutInMs)
+  let _ = op.addInput(address)
+  let _ = op.addInput(method)
+  let _ = op.addInput(request)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func twoFloatInputs(
+  _ a: Tensor<Float>,
+  _ b: Tensor<Float>
+) {
+  let op = TFE_Op("TwoFloatInputs")
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func twoFloatInputsFloatOutput(
+  _ a: Tensor<Float>,
+  _ b: Tensor<Float>
+) -> Tensor<Float> {
+  let op = TFE_Op("TwoFloatInputsFloatOutput")
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func twoFloatInputsIntOutput(
+  _ a: Tensor<Float>,
+  _ b: Tensor<Float>
+) -> Tensor<Int32> {
+  let op = TFE_Op("TwoFloatInputsIntOutput")
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func twoFloatOutputs(
+) -> (a: Tensor<Float>, b: Tensor<Float>) {
+  let op = TFE_Op("TwoFloatOutputs")
+  
+  return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func twoIntInputs(
+  _ a: Tensor<Int32>,
+  _ b: Tensor<Int32>
+) {
+  let op = TFE_Op("TwoIntInputs")
+  let _ = op.addInput(a)
+  let _ = op.addInput(b)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func twoIntOutputs(
+) -> (a: Tensor<Int32>, b: Tensor<Int32>) {
+  let op = TFE_Op("TwoIntOutputs")
+  
+  return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func typeList<T: TensorArrayProtocol>(
+  _ a: T
+) {
+  let op = TFE_Op("TypeList")
+  op.setAttr("T", a._typeList)
+  let _ = op.addInputList(a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func typeListRestrict<T: TensorArrayProtocol>(
+  _ a: T
+) {
+  let op = TFE_Op("TypeListRestrict")
+  op.setAttr("T", a._typeList)
+  let _ = op.addInputList(a)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func typeListTwice<T: TensorArrayProtocol>(
+  _ a: T,
+  _ b: T
+) {
+  let op = TFE_Op("TypeListTwice")
+  op.setAttr("T", a._typeList)
+  let _ = op.addInputList(a)
+  let _ = op.addInputList(b)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func unary<T: TensorFlowScalar>(
+  _ a: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Unary")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(a)
+  return op.execute(Int(1))
+}
+
+/// Reverses the operation of Batch for a single output Tensor.
+///
+/// An instance of Unbatch either receives an empty batched_tensor, in which case it
+/// asynchronously waits until the values become available from a concurrently
+/// running instance of Unbatch with the same container and shared_name, or receives
+/// a non-empty batched_tensor in which case it finalizes all other concurrently
+/// running instances and outputs its own element from the batch.
+///
+/// batched_tensor: The possibly transformed output of Batch. The size of the first
+///  dimension should remain unchanged by the transformations for the operation to
+///  work.
+/// batch_index: The matching batch_index obtained from Batch.
+/// id: The id scalar emitted by Batch.
+/// unbatched_tensor: The Tensor corresponding to this execution.
+/// timeout_micros: Maximum amount of time (in microseconds) to wait to receive the
+///  batched input tensor associated with a given invocation of the op.
+/// container: Container to control resource sharing.
+/// shared_name: Instances of Unbatch with the same container and shared_name are
+///  assumed to possibly belong to the same batch. If left empty, the op name will
+///  be used as the shared name.
+@inlinable @inline(__always)
+public static func unbatch<T: TensorFlowScalar>(
+  batchedTensor: Tensor<T>,
+  batchIndex: Tensor<Int64>,
+  id: Tensor<Int64>,
+  timeoutMicros: Int64,
+  container: String,
+  sharedName: String
+) -> Tensor<T> {
+  let op = TFE_Op("Unbatch")
+  op.setAttr("timeout_micros", timeoutMicros)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(batchedTensor)
+  let _ = op.addInput(batchIndex)
+  let _ = op.addInput(id)
+  return op.execute(Int(1))
+}
+
+/// Gradient of Unbatch.
+///
+/// Acts like Batch but using the given batch_index index of batching things as they
+/// become available. This ensures that the gradients are propagated back in the
+/// same session which did the forward pass.
+///
+/// original_input: The input to the Unbatch operation this is the gradient of.
+/// batch_index: The batch_index given to the Unbatch operation this is the gradient
+/// of.
+/// grad: The downstream gradient.
+/// id: The id scalar emitted by Batch.
+/// batched_grad: The return value, either an empty tensor or the batched gradient.
+/// container: Container to control resource sharing.
+/// shared_name: Instances of UnbatchGrad with the same container and shared_name
+///  are assumed to possibly belong to the same batch. If left empty, the op name
+///  will be used as the shared name.
+@inlinable @inline(__always)
+public static func unbatchGrad<T: TensorFlowScalar>(
+  originalInput: Tensor<T>,
+  batchIndex: Tensor<Int64>,
+  grad: Tensor<T>,
+  id: Tensor<Int64>,
+  container: String,
+  sharedName: String
+) -> Tensor<T> {
+  let op = TFE_Op("UnbatchGrad")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(originalInput)
+  let _ = op.addInput(batchIndex)
+  let _ = op.addInput(grad)
+  let _ = op.addInput(id)
+  return op.execute(Int(1))
+}
+
+/// Decodes each string in `input` into a sequence of Unicode code points.
+///
+/// The character codepoints for all strings are returned using a single vector
+/// `char_values`, with strings expanded to characters in row-major order.
+///
+/// The `row_splits` tensor indicates where the codepoints for
+/// each input string begin and end within the `char_values` tensor.
+/// In particular, the values for the `i`th
+/// string (in row-major order) are stored in the slice
+/// `[row_splits[i]:row_splits[i+1]]`. Thus:
+///
+/// * `char_values[row_splits[i]+j]` is the Unicode codepoint for the `j`th
+///   character in the `i`th string (in row-major order).
+/// * `row_splits[i+1] - row_splits[i]` is the number of characters in the `i`th
+///   string (in row-major order).
+///
+/// - Parameter input: The text to be decoded. Can have any shape. Note that the output is flattened
+///   to a vector of char values.
+///
+/// - Attrs:
+///   - input_encoding: Text encoding of the input strings. This is any of the encodings supported
+///     by ICU ucnv algorithmic converters. Examples: `"UTF-16", "US ASCII", "UTF-8"`.
+///   - errors: Error handling policy when there is invalid formatting found in the input.
+///     The value of 'strict' will cause the operation to produce a InvalidArgument
+///     error on any invalid input formatting. A value of 'replace' (the default) will
+///     cause the operation to replace any invalid formatting in the input with the
+///     `replacement_char` codepoint. A value of 'ignore' will cause the operation to
+///     skip any invalid formatting in the input and produce no corresponding output
+///     character.
+///   - replacement_char: The replacement character codepoint to be used in place of any invalid
+///     formatting in the input when `errors='replace'`. Any valid unicode codepoint may
+///     be used. The default value is the default unicode replacement character is
+///     0xFFFD or U+65533.)
+///   - replace_control_characters: Whether to replace the C0 control characters (00-1F) with the
+///     `replacement_char`. Default is false.
+///
+/// - Outputs:
+///   - row_splits: A 1D int32 tensor containing the row splits.
+///   - char_values: A 1D int32 Tensor containing the decoded codepoints.
+@inlinable @inline(__always)
+public static func unicodeDecode(
+  _ input: StringTensor,
+  inputEncoding: String,
+  errors: Errors = .replace,
+  replacementChar: Int64 = 65533,
+  replaceControlCharacters: Bool = false
+) -> (rowSplits: Tensor<Int64>, charValues: Tensor<Int32>) {
+  let op = TFE_Op("UnicodeDecode")
+  op.setAttr("input_encoding", inputEncoding)
+  op.setAttr("errors", errors.cName)
+  op.setAttr("replacement_char", replacementChar)
+  op.setAttr("replace_control_characters", replaceControlCharacters)
+  let _ = op.addInput(input)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Decodes each string in `input` into a sequence of Unicode code points.
+///
+/// The character codepoints for all strings are returned using a single vector
+/// `char_values`, with strings expanded to characters in row-major order.
+/// Similarly, the character start byte offsets are returned using a single vector
+/// `char_to_byte_starts`, with strings expanded in row-major order.
+///
+/// The `row_splits` tensor indicates where the codepoints and start offsets for
+/// each input string begin and end within the `char_values` and
+/// `char_to_byte_starts` tensors.  In particular, the values for the `i`th
+/// string (in row-major order) are stored in the slice
+/// `[row_splits[i]:row_splits[i+1]]`. Thus:
+///
+/// * `char_values[row_splits[i]+j]` is the Unicode codepoint for the `j`th
+///   character in the `i`th string (in row-major order).
+/// * `char_to_bytes_starts[row_splits[i]+j]` is the start byte offset for the `j`th
+///   character in the `i`th string (in row-major order).
+/// * `row_splits[i+1] - row_splits[i]` is the number of characters in the `i`th
+///   string (in row-major order).
+///
+/// - Parameter input: The text to be decoded. Can have any shape. Note that the output is flattened
+///   to a vector of char values.
+///
+/// - Attrs:
+///   - input_encoding: Text encoding of the input strings. This is any of the encodings supported
+///     by ICU ucnv algorithmic converters. Examples: `"UTF-16", "US ASCII", "UTF-8"`.
+///   - errors: Error handling policy when there is invalid formatting found in the input.
+///     The value of 'strict' will cause the operation to produce a InvalidArgument
+///     error on any invalid input formatting. A value of 'replace' (the default) will
+///     cause the operation to replace any invalid formatting in the input with the
+///     `replacement_char` codepoint. A value of 'ignore' will cause the operation to
+///     skip any invalid formatting in the input and produce no corresponding output
+///     character.
+///   - replacement_char: The replacement character codepoint to be used in place of any invalid
+///     formatting in the input when `errors='replace'`. Any valid unicode codepoint may
+///     be used. The default value is the default unicode replacement character is
+///     0xFFFD or U+65533.)
+///   - replace_control_characters: Whether to replace the C0 control characters (00-1F) with the
+///     `replacement_char`. Default is false.
+///
+/// - Outputs:
+///   - row_splits: A 1D int32 tensor containing the row splits.
+///   - char_values: A 1D int32 Tensor containing the decoded codepoints.
+///   - char_to_byte_starts: A 1D int32 Tensor containing the byte index in the input string where each
+///     character in `char_values` starts.
+@inlinable @inline(__always)
+public static func unicodeDecodeWithOffsets(
+  _ input: StringTensor,
+  inputEncoding: String,
+  errors: Errors = .replace,
+  replacementChar: Int64 = 65533,
+  replaceControlCharacters: Bool = false
+) -> (rowSplits: Tensor<Int64>, charValues: Tensor<Int32>, charToByteStarts: Tensor<Int64>) {
+  let op = TFE_Op("UnicodeDecodeWithOffsets")
+  op.setAttr("input_encoding", inputEncoding)
+  op.setAttr("errors", errors.cName)
+  op.setAttr("replacement_char", replacementChar)
+  op.setAttr("replace_control_characters", replaceControlCharacters)
+  let _ = op.addInput(input)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Encode a tensor of ints into unicode strings.
+///
+/// Returns a vector of strings, where `output[i]` is constructed by encoding the
+/// Unicode codepoints in `input_values[input_splits[i]:input_splits[i+1]]`
+/// using `output_encoding`.
+///
+/// ---
+///
+/// Example:
+///
+/// ```
+/// input_values = [72, 101, 108, 108, 111, 87, 111, 114, 108, 100]
+/// input_splits = [0, 5, 10]
+/// output_encoding = 'UTF-8'
+///
+/// output = ['Hello', 'World']
+/// ```
+///
+/// - Parameters:
+///   - input_values: A 1D tensor containing the unicode codepoints that should be encoded.
+///   - input_splits: A 1D tensor specifying how the unicode codepoints should be split into strings.
+///     In particular, `output[i]` is constructed by encoding the codepoints in the
+///     slice `input_values[input_splits[i]:input_splits[i+1]]`.
+///
+/// - Attrs:
+///   - errors: Error handling policy when there is invalid formatting found in the input.
+///     The value of 'strict' will cause the operation to produce a InvalidArgument
+///     error on any invalid input formatting. A value of 'replace' (the default) will
+///     cause the operation to replace any invalid formatting in the input with the
+///     `replacement_char` codepoint. A value of 'ignore' will cause the operation to
+///     skip any invalid formatting in the input and produce no corresponding output
+///     character.
+///   - output_encoding: Unicode encoding of the output strings. Valid encodings are: `"UTF-8",
+///     "UTF-16-BE", and "UTF-32-BE"`.
+///   - replacement_char: The replacement character codepoint to be used in place of any invalid
+///     formatting in the input when `errors='replace'`. Any valid unicode codepoint may
+///     be used. The default value is the default unicode replacement character is
+///     0xFFFD (U+65533).
+///
+/// - Output output: The 1-D Tensor of strings encoded from the provided unicode codepoints.
+@inlinable @inline(__always)
+public static func unicodeEncode(
+  inputValues: Tensor<Int32>,
+  inputSplits: Tensor<Int64>,
+  errors: Errors = .replace,
+  outputEncoding: OutputEncoding,
+  replacementChar: Int64 = 65533
+) -> StringTensor {
+  let op = TFE_Op("UnicodeEncode")
+  op.setAttr("errors", errors.cName)
+  op.setAttr("output_encoding", outputEncoding.cName)
+  op.setAttr("replacement_char", replacementChar)
+  let _ = op.addInput(inputValues)
+  let _ = op.addInput(inputSplits)
+  return op.execute(Int(1))
+}
+
+/// Determine the script codes of a given tensor of Unicode integer code points.
+///
+/// This operation converts Unicode code points to script codes corresponding to
+/// each code point. Script codes correspond to International Components for
+/// Unicode (ICU) UScriptCode values. See http://icu-project.org/apiref/icu4c/uscript_8h.html.
+/// Returns -1 (USCRIPT_INVALID_CODE) for invalid codepoints. Output shape will
+/// match input shape.
+///
+/// - Parameter input: A Tensor of int32 Unicode code points.
+///
+/// - Output output: A Tensor of int32 script codes corresponding to each input code point.
+@inlinable @inline(__always)
+public static func unicodeScript(
+  _ input: Tensor<Int32>
+) -> Tensor<Int32> {
+  let op = TFE_Op("UnicodeScript")
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Transcode the input text from a source encoding to a destination encoding.
+///
+/// The input is a string tensor of any shape. The output is a string tensor of
+/// the same shape containing the transcoded strings. Output strings are always
+/// valid unicode. If the input contains invalid encoding positions, the
+/// `errors` attribute sets the policy for how to deal with them. If the default
+/// error-handling policy is used, invalid formatting will be substituted in the
+/// output by the `replacement_char`. If the errors policy is to `ignore`, any
+/// invalid encoding positions in the input are skipped and not included in the
+/// output. If it set to `strict` then any invalid formatting will result in an
+/// InvalidArgument error.
+///
+/// This operation can be used with `output_encoding = input_encoding` to enforce
+/// correct formatting for inputs even if they are already in the desired encoding.
+///
+/// If the input is prefixed by a Byte Order Mark needed to determine encoding
+/// (e.g. if the encoding is UTF-16 and the BOM indicates big-endian), then that
+/// BOM will be consumed and not emitted into the output. If the input encoding
+/// is marked with an explicit endianness (e.g. UTF-16-BE), then the BOM is
+/// interpreted as a non-breaking-space and is preserved in the output (including
+/// always for UTF-8).
+///
+/// The end result is that if the input is marked as an explicit endianness the
+/// transcoding is faithful to all codepoints in the source. If it is not marked
+/// with an explicit endianness, the BOM is not considered part of the string itself
+/// but as metadata, and so is not preserved in the output.
+///
+/// - Parameter input: The text to be processed. Can have any shape.
+///
+/// - Attrs:
+///   - input_encoding: Text encoding of the input strings. This is any of the encodings supported
+///     by ICU ucnv algorithmic converters. Examples: `"UTF-16", "US ASCII", "UTF-8"`.
+///   - output_encoding: The unicode encoding to use in the output. Must be one of
+///     `"UTF-8", "UTF-16-BE", "UTF-32-BE"`. Multi-byte encodings will be big-endian.
+///   - errors: Error handling policy when there is invalid formatting found in the input.
+///     The value of 'strict' will cause the operation to produce a InvalidArgument
+///     error on any invalid input formatting. A value of 'replace' (the default) will
+///     cause the operation to replace any invalid formatting in the input with the
+///     `replacement_char` codepoint. A value of 'ignore' will cause the operation to
+///     skip any invalid formatting in the input and produce no corresponding output
+///     character.
+///   - replacement_char: The replacement character codepoint to be used in place of any invalid
+///     formatting in the input when `errors='replace'`. Any valid unicode codepoint may
+///     be used. The default value is the default unicode replacement character is
+///     0xFFFD or U+65533.)
+///
+///     Note that for UTF-8, passing a replacement character expressible in 1 byte, such
+///     as ' ', will preserve string alignment to the source since invalid bytes will be
+///     replaced with a 1-byte replacement. For UTF-16-BE and UTF-16-LE, any 1 or 2 byte
+///     replacement character will preserve byte alignment to the source.
+///   - replace_control_characters: Whether to replace the C0 control characters (00-1F) with the
+///     `replacement_char`. Default is false.
+///
+/// - Output output: A string tensor containing unicode text encoded using `output_encoding`.
+@inlinable @inline(__always)
+public static func unicodeTranscode(
+  _ input: StringTensor,
+  inputEncoding: String,
+  outputEncoding: OutputEncoding,
+  errors: Errors = .replace,
+  replacementChar: Int64 = 65533,
+  replaceControlCharacters: Bool = false
+) -> StringTensor {
+  let op = TFE_Op("UnicodeTranscode")
+  op.setAttr("input_encoding", inputEncoding)
+  op.setAttr("output_encoding", outputEncoding.cName)
+  op.setAttr("errors", errors.cName)
+  op.setAttr("replacement_char", replacementChar)
+  op.setAttr("replace_control_characters", replaceControlCharacters)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Generates labels for candidate sampling with a uniform distribution.
+///
+/// See explanations of candidate sampling and the data formats at
+/// go/candidate-sampling.
+///
+/// For each batch, this op picks a single set of sampled candidate labels.
+///
+/// The advantages of sampling candidates per-batch are simplicity and the
+/// possibility of efficient dense matrix multiplication. The disadvantage is that
+/// the sampled candidates must be chosen independently of the context and of the
+/// true labels.
+///
+/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
+///   IDs of the num_true target_classes in the corresponding original label.
+///
+/// - Attrs:
+///   - num_true: Number of true labels per context.
+///   - num_sampled: Number of candidates to randomly sample.
+///   - unique: If unique is true, we sample with rejection, so that all sampled
+///     candidates in a batch are unique. This requires some approximation to
+///     estimate the post-rejection sampling probabilities.
+///   - range_max: The sampler will sample integers from the interval [0, range_max).
+///   - seed: If either seed or seed2 are set to be non-zero, the random number
+///     generator is seeded by the given seed.  Otherwise, it is seeded by a
+///     random seed.
+///   - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///   - sampled_candidates: A vector of length num_sampled, in which each element is
+///     the ID of a sampled candidate.
+///   - true_expected_count: A batch_size * num_true matrix, representing
+///     the number of times each candidate is expected to occur in a batch
+///     of sampled candidates. If unique=true, then this is a probability.
+///   - sampled_expected_count: A vector of length num_sampled, for each sampled
+///     candidate representing the number of times the candidate is expected
+///     to occur in a batch of sampled candidates.  If unique=true, then this is a
+///     probability.
+@inlinable @inline(__always)
+public static func uniformCandidateSampler(
+  trueClasses: Tensor<Int64>,
+  numTrue: Int64,
+  numSampled: Int64,
+  unique: Bool,
+  rangeMax: Int64,
+  seed: Int64 = 0,
+  seed2: Int64 = 0
+) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
+  let op = TFE_Op("UniformCandidateSampler")
+  op.setAttr("num_true", numTrue)
+  op.setAttr("num_sampled", numSampled)
+  op.setAttr("unique", unique)
+  op.setAttr("range_max", rangeMax)
+  op.setAttr("seed", seed)
+  op.setAttr("seed2", seed2)
+  let _ = op.addInput(trueClasses)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Finds unique elements in a 1-D tensor.
+///
+/// This operation returns a tensor `y` containing all of the unique elements of `x`
+/// sorted in the same order that they occur in `x`. This operation also returns a
+/// tensor `idx` the same size as `x` that contains the index of each value of `x`
+/// in the unique output `y`. In other words:
+///
+/// `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+///
+/// For example:
+///
+/// ```
+/// # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
+/// y, idx = unique(x)
+/// y ==> [1, 2, 4, 7, 8]
+/// idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
+/// ```
+///
+/// - Parameter x: 1-D.
+///
+/// - Outputs:
+///   - y: 1-D.
+///   - idx: 1-D.
+@inlinable @inline(__always)
+public static func unique<
+    T: TensorFlowScalar,
+    OutIdx: BinaryInteger & TensorFlowScalar
+>(
+  _ x: Tensor<T>
+) -> (y: Tensor<T>, idx: Tensor<OutIdx>) {
+  let op = TFE_Op("Unique")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_idx", OutIdx.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Finds unique elements along an axis of a tensor.
+///
+/// This operation either returns a tensor `y` containing unique elements
+/// along the `axis` of a tensor. The returned unique elements is sorted
+/// in the same order as they occur along `axis` in `x`.
+/// This operation also returns a tensor `idx` that is the same size as
+/// the number of the elements in `x` along the `axis` dimension. It
+/// contains the index in the unique output `y`.
+/// In other words, for an `1-D` tensor `x` with `axis = None:
+///
+/// `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+///
+/// For example:
+///
+/// ```
+/// # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
+/// y, idx = unique(x)
+/// y ==> [1, 2, 4, 7, 8]
+/// idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
+/// ```
+///
+/// For an `2-D` tensor `x` with `axis = 0`:
+///
+/// ```
+/// # tensor 'x' is [[1, 0, 0],
+/// #                [1, 0, 0],
+/// #                [2, 0, 0]]
+/// y, idx = unique(x, axis=0)
+/// y ==> [[1, 0, 0],
+///        [2, 0, 0]]
+/// idx ==> [0, 0, 1]
+/// ```
+///
+/// For an `2-D` tensor `x` with `axis = 1`:
+///
+/// ```
+/// # tensor 'x' is [[1, 0, 0],
+/// #                [1, 0, 0],
+/// #                [2, 0, 0]]
+/// y, idx = unique(x, axis=1)
+/// y ==> [[1, 0],
+///        [1, 0],
+///        [2, 0]]
+/// idx ==> [0, 1, 1]
+/// ```
+///
+/// - Parameters:
+///   - x: A `Tensor`.
+///   - axis: A `Tensor` of type `int32` (default: None). The axis of the Tensor to
+///     find the unique elements.
+///
+/// - Outputs:
+///   - y: A `Tensor`. Unique elements along the `axis` of `Tensor` x.
+///   - idx: A 1-D Tensor. Has the same type as x that contains the index of each
+///     value of x in the output y.
+@inlinable @inline(__always)
+public static func uniqueV2<
+    T: TensorFlowScalar,
+    Taxis: BinaryInteger & TensorFlowScalar,
+    OutIdx: BinaryInteger & TensorFlowScalar
+>(
+  _ x: Tensor<T>,
+  axis: Tensor<Taxis>
+) -> (y: Tensor<T>, idx: Tensor<OutIdx>) {
+  let op = TFE_Op("UniqueV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Taxis", Taxis.tensorFlowDataType)
+  op.setAttr("out_idx", OutIdx.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(axis)
+  return op.execute(Int(1), Int(1))
+}
+
+/// Finds unique elements in a 1-D tensor.
+///
+/// This operation returns a tensor `y` containing all of the unique elements of `x`
+/// sorted in the same order that they occur in `x`. This operation also returns a
+/// tensor `idx` the same size as `x` that contains the index of each value of `x`
+/// in the unique output `y`. Finally, it returns a third tensor `count` that
+/// contains the count of each element of `y` in `x`. In other words:
+///
+/// `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+///
+/// For example:
+///
+/// ```
+/// # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
+/// y, idx, count = unique_with_counts(x)
+/// y ==> [1, 2, 4, 7, 8]
+/// idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
+/// count ==> [2, 1, 3, 1, 2]
+/// ```
+///
+/// - Parameter x: 1-D.
+///
+/// - Outputs:
+///   - y: 1-D.
+///   - idx: 1-D.
+///   - count: 1-D.
+@inlinable @inline(__always)
+public static func uniqueWithCounts<
+    T: TensorFlowScalar,
+    OutIdx: BinaryInteger & TensorFlowScalar
+>(
+  _ x: Tensor<T>
+) -> (y: Tensor<T>, idx: Tensor<OutIdx>, count: Tensor<OutIdx>) {
+  let op = TFE_Op("UniqueWithCounts")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_idx", OutIdx.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Finds unique elements along an axis of a tensor.
+///
+/// This operation either returns a tensor `y` containing unique elements
+/// along the `axis` of a tensor. The returned unique elements is sorted
+/// in the same order as they occur along `axis` in `x`.
+/// This operation also returns a tensor `idx` and a tensor `count`
+/// that are the same size as the number of the elements in `x` along the
+/// `axis` dimension. The `idx` contains the index in the unique output `y`
+/// and the `count` contains the count in the unique output `y`.
+/// In other words, for an `1-D` tensor `x` with `axis = None:
+///
+/// `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+///
+/// For example:
+///
+/// ```
+/// # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
+/// y, idx, count = unique_with_counts(x)
+/// y ==> [1, 2, 4, 7, 8]
+/// idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
+/// count ==> [2, 1, 3, 1, 2]
+/// ```
+///
+/// For an `2-D` tensor `x` with `axis = 0`:
+///
+/// ```
+/// # tensor 'x' is [[1, 0, 0],
+/// #                [1, 0, 0],
+/// #                [2, 0, 0]]
+/// y, idx, count = unique_with_counts(x, axis=0)
+/// y ==> [[1, 0, 0],
+///        [2, 0, 0]]
+/// idx ==> [0, 0, 1]
+/// count ==> [2, 1]
+/// ```
+///
+/// For an `2-D` tensor `x` with `axis = 1`:
+///
+/// ```
+/// # tensor 'x' is [[1, 0, 0],
+/// #                [1, 0, 0],
+/// #                [2, 0, 0]]
+/// y, idx, count = unique_with_counts(x, axis=1)
+/// y ==> [[1, 0],
+///        [1, 0],
+///        [2, 0]]
+/// idx ==> [0, 1, 1]
+/// count ==> [1, 2]
+/// ```
+///
+/// - Parameters:
+///   - x: A `Tensor`.
+///   - axis: A `Tensor` of type `int32` (default: None). The axis of the Tensor to
+///     find the unique elements.
+///
+/// - Outputs:
+///   - y: A `Tensor`. Unique elements along the `axis` of `Tensor` x.
+///   - idx: A 1-D Tensor. Has the same type as x that contains the index of each
+///     value of x in the output y.
+///   - count: A 1-D Tensor. The count of each value of x in the output y.
+@inlinable @inline(__always)
+public static func uniqueWithCountsV2<
+    T: TensorFlowScalar,
+    Taxis: BinaryInteger & TensorFlowScalar,
+    OutIdx: BinaryInteger & TensorFlowScalar
+>(
+  _ x: Tensor<T>,
+  axis: Tensor<Taxis>
+) -> (y: Tensor<T>, idx: Tensor<OutIdx>, count: Tensor<OutIdx>) {
+  let op = TFE_Op("UniqueWithCountsV2")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Taxis", Taxis.tensorFlowDataType)
+  op.setAttr("out_idx", OutIdx.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(axis)
+  return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Unpacks a given dimension of a rank-`R` tensor into `num` rank-`(R-1)` tensors.
+///
+/// Unpacks `num` tensors from `value` by chipping it along the `axis` dimension.
+/// For example, given a tensor of shape `(A, B, C, D)`;
+///
+/// If `axis == 0` then the i'th tensor in `output` is the slice `value[i, :, :, :]`
+///   and each tensor in `output` will have shape `(B, C, D)`. (Note that the
+///   dimension unpacked along is gone, unlike `split`).
+///
+/// If `axis == 1` then the i'th tensor in `output` is the slice `value[:, i, :, :]`
+///   and each tensor in `output` will have shape `(A, C, D)`.
+/// Etc.
+///
+/// This is the opposite of `pack`.
+///
+/// - Parameter value: 1-D or higher, with `axis` dimension size equal to `num`.
+///
+/// - Attr axis: Dimension along which to unpack.  Negative values wrap around, so the
+///   valid range is `[-R, R)`.
+///
+/// - Output output: The list of tensors unpacked from `value`.
+@inlinable @inline(__always)
+public static func unpack<T: TensorFlowScalar>(
+  value: Tensor<T>,
+  num: Int64,
+  axis: Int64 = 0
+) -> [Tensor<T>] {
+  let op = TFE_Op("Unpack")
+  op.setAttr("num", num)
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("axis", axis)
+  let _ = op.addInput(value)
+  return op.execute(Int(num))
+}
+
+/// Converts a flat index or array of flat indices into a tuple of
+///
+/// coordinate arrays.
+///
+/// @compatibility(numpy)
+/// Equivalent to np.unravel_index
+/// @end_compatibility
+///
+/// - Parameters:
+///   - indices: An 0-D or 1-D `int` Tensor whose elements are indices into the
+///     flattened version of an array of dimensions dims.
+///   - dims: An 1-D `int` Tensor. The shape of the array to use for unraveling
+///     indices.
+///
+/// - Output output: An 2-D (or 1-D if indices is 0-D) tensor where each row has the
+///   same shape as the indices array.
+@inlinable @inline(__always)
+public static func unravelIndex<Tidx: BinaryInteger & TensorFlowScalar>(
+  indices: Tensor<Tidx>,
+  dims: Tensor<Tidx>
+) -> Tensor<Tidx> {
+  let op = TFE_Op("UnravelIndex")
+  op.setAttr("Tidx", Tidx.tensorFlowDataType)
+  let _ = op.addInput(indices)
+  let _ = op.addInput(dims)
+  return op.execute(Int(1))
+}
+
+/// Computes the maximum along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// This operator is similar to the unsorted segment sum operator found
+/// [(here)](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
+/// Instead of computing the sum over segments, it computes the maximum such that:
+///
+/// \\(output_i = \max_{j...} data[j...]\\) where max is over tuples `j...` such
+/// that `segment_ids[j...] == i`.
+///
+/// If the maximum is empty for a given segment ID `i`, it outputs the smallest
+/// possible value for the specific numeric type,
+/// `output[i] = numeric_limits<T>::lowest()`.
+///
+/// If the given segment ID `i` is negative, then the corresponding value is
+/// dropped, and will not be included in the result.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/UnsortedSegmentMax.png" alt>
+/// </div>
+///
+/// For example:
+///
+/// ``` python
+/// c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]])
+/// tf.unsorted_segment_max(c, tf.constant([0, 1, 0]), num_segments=2)
+/// # ==> [[ 4,  3, 3, 4],
+/// #       [5,  6, 7, 8]]
+/// ```
+///
+///
+/// - Parameter segment_ids: A tensor whose shape is a prefix of `data.shape`.
+///
+/// - Output output: Has same shape as data, except for the first `segment_ids.rank`
+///   dimensions, which are replaced with a single dimension which has size
+///   `num_segments`.
+@inlinable @inline(__always)
+public static func unsortedSegmentMax<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  segmentIds: Tensor<Tindices>,
+  numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let op = TFE_Op("UnsortedSegmentMax")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(segmentIds)
+  let _ = op.addInput(numSegments)
+  return op.execute(Int(1))
+}
+
+/// Computes the minimum along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// This operator is similar to the unsorted segment sum operator found
+/// [(here)](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
+/// Instead of computing the sum over segments, it computes the minimum such that:
+///
+/// \\(output_i = \min_{j...} data_[j...]\\) where min is over tuples `j...` such
+/// that `segment_ids[j...] == i`.
+///
+/// If the minimum is empty for a given segment ID `i`, it outputs the largest
+/// possible value for the specific numeric type,
+/// `output[i] = numeric_limits<T>::max()`.
+///
+/// For example:
+///
+/// ``` python
+/// c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]])
+/// tf.unsorted_segment_min(c, tf.constant([0, 1, 0]), num_segments=2)
+/// # ==> [[ 1,  2, 2, 1],
+/// #       [5,  6, 7, 8]]
+/// ```
+///
+/// If the given segment ID `i` is negative, then the corresponding value is
+/// dropped, and will not be included in the result.
+///
+/// - Parameter segment_ids: A tensor whose shape is a prefix of `data.shape`.
+///
+/// - Output output: Has same shape as data, except for the first `segment_ids.rank`
+///   dimensions, which are replaced with a single dimension which has size
+///   `num_segments`.
+@inlinable @inline(__always)
+public static func unsortedSegmentMin<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  segmentIds: Tensor<Tindices>,
+  numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let op = TFE_Op("UnsortedSegmentMin")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(segmentIds)
+  let _ = op.addInput(numSegments)
+  return op.execute(Int(1))
+}
+
+/// Computes the product along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// This operator is similar to the unsorted segment sum operator found
+/// [(here)](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
+/// Instead of computing the sum over segments, it computes the product of all
+/// entries belonging to a segment such that:
+///
+/// \\(output_i = \prod_{j...} data[j...]\\) where the product is over tuples
+/// `j...` such that `segment_ids[j...] == i`.
+///
+/// For example:
+///
+/// ``` python
+/// c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]])
+/// tf.unsorted_segment_prod(c, tf.constant([0, 1, 0]), num_segments=2)
+/// # ==> [[ 4,  6, 6, 4],
+/// #       [5,  6, 7, 8]]
+/// ```
+///
+/// If there is no entry for a given segment ID `i`, it outputs 1.
+///
+/// If the given segment ID `i` is negative, then the corresponding value is
+/// dropped, and will not be included in the result.
+///
+/// - Parameter segment_ids: A tensor whose shape is a prefix of `data.shape`.
+///
+/// - Output output: Has same shape as data, except for the first `segment_ids.rank`
+///   dimensions, which are replaced with a single dimension which has size
+///   `num_segments`.
+@inlinable @inline(__always)
+public static func unsortedSegmentProd<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  segmentIds: Tensor<Tindices>,
+  numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let op = TFE_Op("UnsortedSegmentProd")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(segmentIds)
+  let _ = op.addInput(numSegments)
+  return op.execute(Int(1))
+}
+
+/// Computes the sum along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Computes a tensor such that
+/// \\(output[i] = \sum_{j...} data[j...]\\) where the sum is over tuples `j...` such
+/// that `segment_ids[j...] == i`.  Unlike `SegmentSum`, `segment_ids`
+/// need not be sorted and need not cover all values in the full
+/// range of valid values.
+///
+/// If the sum is empty for a given segment ID `i`, `output[i] = 0`.
+/// If the given segment ID `i` is negative, the value is dropped and will not be
+/// added to the sum of the segment.
+///
+/// `num_segments` should equal the number of distinct segment IDs.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/UnsortedSegmentSum.png" alt>
+/// </div>
+///
+/// ``` python
+/// c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]])
+/// tf.unsorted_segment_sum(c, tf.constant([0, 1, 0]), num_segments=2)
+/// # ==> [[ 5,  5, 5, 5],
+/// #       [5,  6, 7, 8]]
+/// ```
+///
+///
+/// - Parameter segment_ids: A tensor whose shape is a prefix of `data.shape`.
+///
+/// - Output output: Has same shape as data, except for the first `segment_ids.rank`
+///   dimensions, which are replaced with a single dimension which has size
+///   `num_segments`.
+@inlinable @inline(__always)
+public static func unsortedSegmentSum<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+  data: Tensor<T>,
+  segmentIds: Tensor<Tindices>,
+  numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let op = TFE_Op("UnsortedSegmentSum")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("Tindices", Tindices.tensorFlowDataType)
+  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
+  let _ = op.addInput(data)
+  let _ = op.addInput(segmentIds)
+  let _ = op.addInput(numSegments)
+  return op.execute(Int(1))
+}
+
+/// Op is similar to a lightweight Dequeue.
+///
+/// The basic functionality is similar to dequeue with many fewer
+/// capabilities and options.  This Op is optimized for performance.
+@inlinable @inline(__always)
+public static func unstage<Dtypes: TensorGroup>(
+  capacity: Int64 = 0,
+  memoryLimit: Int64 = 0,
+  container: String,
+  sharedName: String
+) -> Dtypes {
+  let op = TFE_Op("Unstage")
+  op.setAttr("capacity", capacity)
+  op.setAttr("memory_limit", memoryLimit)
+  op.setAttr("dtypes", Dtypes._typeList)
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(Dtypes._typeList.count))
+}
+
+@inlinable @inline(__always)
+public static func unwrapDatasetVariant(
+  inputHandle: VariantHandle
+) -> VariantHandle {
+  let op = TFE_Op("UnwrapDatasetVariant")
+  let _ = op.addInput(inputHandle)
+  return op.execute(Int(1))
+}
+
+/// Applies upper_bound(sorted_search_values, values) along each row.
+///
+/// Each set of rows with the same index in (sorted_inputs, values) is treated
+/// independently.  The resulting row is the equivalent of calling
+/// `np.searchsorted(sorted_inputs, values, side='right')`.
+///
+/// The result is not a global index to the entire 
+/// `Tensor`, but rather just the index in the last dimension.
+///
+/// A 2-D example:
+///   sorted_sequence = [[0, 3, 9, 9, 10],
+///                      [1, 2, 3, 4, 5]]
+///   values = [[2, 4, 9],
+///             [0, 2, 6]]
+///
+///   result = UpperBound(sorted_sequence, values)
+///
+///   result == [[1, 2, 4],
+///              [0, 2, 5]]
+///
+/// - Parameters:
+///   - sorted_inputs: 2-D Tensor where each row is ordered.
+///   - values: 2-D Tensor with the same numbers of rows as `sorted_search_values`. Contains
+///     the values that will be searched for in `sorted_search_values`.
+///
+/// - Output output: A `Tensor` with the same shape as `values`.  It contains the last scalar index
+///   into the last dimension where values can be inserted without changing the
+///   ordered property.
+@inlinable @inline(__always)
+public static func upperBound<
+    T: TensorFlowScalar,
+    OutType: BinaryInteger & TensorFlowScalar
+>(
+  sortedInputs: Tensor<T>,
+  _ values: Tensor<T>
+) -> Tensor<OutType> {
+  let op = TFE_Op("UpperBound")
+  op.setAttr("T", T.tensorFlowDataType)
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(sortedInputs)
+  let _ = op.addInput(values)
+  return op.execute(Int(1))
+}
+
+/// Creates a handle to a Variable resource.
+///
+/// - Attrs:
+///   - container: the container this variable is placed in.
+///   - shared_name: the name by which this variable is referred to.
+///   - dtype: the type of this variable. Must agree with the dtypes
+///     of all ops using this variable.
+///   - shape: The (possibly partially specified) shape of this variable.
+@inlinable @inline(__always)
+public static func varHandleOp(
+  container: String,
+  sharedName: String,
+  dtype: TensorDataType,
+  shape: TensorShape?
+) -> ResourceHandle {
+  let op = TFE_Op("VarHandleOp")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  op.setAttr("dtype", dtype)
+  op.setAttr("shape", shape)
+  return op.execute(Int(1))
+}
+
+/// Checks whether a resource handle-based variable has been initialized.
+///
+/// - Parameter resource: the input resource handle.
+///
+/// - Output is_initialized: a scalar boolean which is true if the variable has been
+///   initialized.
+@inlinable @inline(__always)
+public static func varIsInitializedOp(
+  resource: ResourceHandle
+) -> Tensor<Bool> {
+  let op = TFE_Op("VarIsInitializedOp")
+  let _ = op.addInput(resource)
+  return op.execute(Int(1))
+}
+
+/// Returns the shape of the variable pointed to by `resource`.
+///
+/// This operation returns a 1-D integer tensor representing the shape of `input`.
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
+/// shape(t) ==> [2, 2, 3]
+/// ```
+@inlinable @inline(__always)
+public static func variableShape<OutType: BinaryInteger & TensorFlowScalar>(
+  _ input: ResourceHandle
+) -> Tensor<OutType> {
+  let op = TFE_Op("VariableShape")
+  op.setAttr("out_type", OutType.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// Returns locations of nonzero / true values in a tensor.
+///
+/// This operation returns the coordinates of true elements in `condition`. The
+/// coordinates are returned in a 2-D tensor where the first dimension (rows)
+/// represents the number of true elements, and the second dimension (columns)
+/// represents the coordinates of the true elements. Keep in mind, the shape of
+/// the output tensor can vary depending on how many true values there are in
+/// `condition`. Indices are output in row-major order.
+///
+/// For example:
+///
+/// ```
+/// # 'input' tensor is [[True, False]
+/// #                    [True, False]]
+/// # 'input' has two true values, so output has two coordinates.
+/// # 'input' has rank of 2, so coordinates have two indices.
+/// where(input) ==> [[0, 0],
+///                   [1, 0]]
+///
+/// # `condition` tensor is [[[True, False]
+/// #                     [True, False]]
+/// #                    [[False, True]
+/// #                     [False, True]]
+/// #                    [[False, False]
+/// #                     [False, True]]]
+/// # 'input' has 5 true values, so output has 5 coordinates.
+/// # 'input' has rank of 3, so coordinates have three indices.
+/// where(input) ==> [[0, 0, 0],
+///                   [0, 1, 0],
+///                   [1, 0, 1],
+///                   [1, 1, 1],
+///                   [2, 1, 1]]
+///
+/// # `condition` tensor is [[[1.5,  0.0]
+/// #                     [-0.5, 0.0]]
+/// #                    [[0.0,  0.25]
+/// #                     [0.0,  0.75]]
+/// #                    [[0.0,  0.0]
+/// #                     [0.0,  0.01]]]
+/// # 'input' has 5 nonzero values, so output has 5 coordinates.
+/// # 'input' has rank of 3, so coordinates have three indices.
+/// where(input) ==> [[0, 0, 0],
+///                   [0, 1, 0],
+///                   [1, 0, 1],
+///                   [1, 1, 1],
+///                   [2, 1, 1]]
+///
+/// # `condition` tensor is [[[1.5 + 0.0j, 0.0  + 0.0j]
+/// #                     [0.0 + 0.5j, 0.0  + 0.0j]]
+/// #                    [[0.0 + 0.0j, 0.25 + 1.5j]
+/// #                     [0.0 + 0.0j, 0.75 + 0.0j]]
+/// #                    [[0.0 + 0.0j, 0.0  + 0.0j]
+/// #                     [0.0 + 0.0j, 0.01 + 0.0j]]]
+/// # 'input' has 5 nonzero magnitude values, so output has 5 coordinates.
+/// # 'input' has rank of 3, so coordinates have three indices.
+/// where(input) ==> [[0, 0, 0],
+///                   [0, 1, 0],
+///                   [1, 0, 1],
+///                   [1, 1, 1],
+///                   [2, 1, 1]]
+/// ```
+@inlinable @inline(__always)
+public static func where_<T: TensorFlowScalar>(
+  _ input: Tensor<T>
+) -> Tensor<Int64> {
+  let op = TFE_Op("Where")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(input)
+  return op.execute(Int(1))
+}
+
+/// output = input; While (Cond(output)) { output = Body(output) }
+///
+/// - Parameter input: A list of input tensors whose types are T.
+///
+/// - Attrs:
+///   - T: dtype in use.
+///   - cond:       A function takes 'input' and returns a tensor.  If the tensor is
+///           a scalar of non-boolean, the scalar is converted to a boolean
+///           according to the following rule: if the scalar is a numerical
+///           value, non-zero means True and zero means False; if the scalar is
+///           a string, non-empty means True and empty means False. If the
+///           tensor is not a scalar, non-emptiness means True and False
+///           otherwise.
+///   - body:       A function that takes a list of tensors and returns another
+///           list of tensors. Both lists have the same types as specified
+///           by T.
+///
+/// - Output output: A list of output tensors whose types are T.
+@inlinable @inline(__always)
+public static func while_<
+    T: TensorArrayProtocol,
+    CondIn: TensorGroup,
+    CondOut: TensorGroup,
+    BodyIn: TensorGroup,
+    BodyOut: TensorGroup
+>(
+  _ input: T,
+  cond: (CondIn) -> CondOut,
+  body: (BodyIn) -> BodyOut,
+  outputShapes: [TensorShape?],
+  parallelIterations: Int64 = 10
+) -> T {
+  let op = TFE_Op("While")
+  op.setAttr("T", input._typeList)
+  op.setAttr("cond", cond)
+  op.setAttr("body", body)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("parallel_iterations", parallelIterations)
+  let _ = op.addInputList(input)
+  return op.execute(Int(input._typeList.count))
+}
+
+/// A Reader that outputs the entire contents of a file as a value.
+///
+/// To use, enqueue filenames in a Queue.  The output of ReaderRead will
+/// be a filename (key) and the contents of that file (value).
+///
+/// - Attrs:
+///   - container: If non-empty, this reader is placed in the given container.
+///     Otherwise, a default container is used.
+///   - shared_name: If non-empty, this reader is named in the given bucket
+///     with this shared_name. Otherwise, the node name is used instead.
+///
+/// - Output reader_handle: The handle to reference the Reader.
+@inlinable @inline(__always)
+public static func wholeFileReaderV2(
+  container: String,
+  sharedName: String
+) -> ResourceHandle {
+  let op = TFE_Op("WholeFileReaderV2")
+  op.setAttr("container", container)
+  op.setAttr("shared_name", sharedName)
+  return op.execute(Int(1))
+}
+
+/// A dataset that creates window datasets from the input dataset.
+///
+/// - Parameters:
+///   - size: A scalar representing the number of elements to accumulate in a window.
+///   - shift: A scalar representing the steps moving the sliding window forward in one
+///     iteration. It must be positive.
+///   - stride: A scalar representing the stride of the input elements of the sliding window.
+///     It must be positive.
+///   - drop_remainder: A scalar representing whether a window should be dropped in case its size is
+///     smaller than desired.
+@inlinable @inline(__always)
+public static func windowDataset(
+  inputDataset: VariantHandle,
+  size: Tensor<Int64>,
+  shift: Tensor<Int64>,
+  stride: Tensor<Int64>,
+  dropRemainder: Tensor<Bool>,
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("WindowDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  let _ = op.addInput(inputDataset)
+  let _ = op.addInput(size)
+  let _ = op.addInput(shift)
+  let _ = op.addInput(stride)
+  let _ = op.addInput(dropRemainder)
+  return op.execute(Int(1))
+}
+
+/// Worker heartbeat op.
+///
+/// Heartbeats may be sent periodically to indicate the coordinator is still active,
+/// to retrieve the current worker status and to expedite shutdown when necessary.
+///
+/// - Parameter request: A string tensor containing a serialized WorkerHeartbeatRequest
+///
+/// - Output response: A string tensor containing a serialized WorkerHeartbeatResponse
+@inlinable @inline(__always)
+public static func workerHeartbeat(
+  request: StringTensor
+) -> StringTensor {
+  let op = TFE_Op("WorkerHeartbeat")
+  let _ = op.addInput(request)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func wrapDatasetVariant(
+  inputHandle: VariantHandle
+) -> VariantHandle {
+  let op = TFE_Op("WrapDatasetVariant")
+  let _ = op.addInput(inputHandle)
+  return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func writeAudioSummary(
+  writer: ResourceHandle,
+  step: Tensor<Int64>,
+  tag: StringTensor,
+  _ tensor: Tensor<Float>,
+  sampleRate: Tensor<Float>,
+  maxOutputs: Int64 = 3
+) {
+  let op = TFE_Op("WriteAudioSummary")
+  op.setAttr("max_outputs", maxOutputs)
+  let _ = op.addInput(writer)
+  let _ = op.addInput(step)
+  let _ = op.addInput(tag)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(sampleRate)
+  op.execute()
+}
+
+/// Writes contents to the file at input filename. Creates file and recursively
+///
+/// creates directory if not existing.
+///
+/// - Parameters:
+///   - filename: scalar. The name of the file to which we write the contents.
+///   - contents: scalar. The content to be written to the output file.
+@inlinable @inline(__always)
+public static func writeFile(
+  filename: StringTensor,
+  contents: StringTensor
+) {
+  let op = TFE_Op("WriteFile")
+  let _ = op.addInput(filename)
+  let _ = op.addInput(contents)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func writeGraphSummary(
+  writer: ResourceHandle,
+  step: Tensor<Int64>,
+  _ tensor: StringTensor
+) {
+  let op = TFE_Op("WriteGraphSummary")
+  let _ = op.addInput(writer)
+  let _ = op.addInput(step)
+  let _ = op.addInput(tensor)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func writeHistogramSummary<T: Numeric & TensorFlowScalar>(
+  writer: ResourceHandle,
+  step: Tensor<Int64>,
+  tag: StringTensor,
+  _ values: Tensor<T>
+) {
+  let op = TFE_Op("WriteHistogramSummary")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(writer)
+  let _ = op.addInput(step)
+  let _ = op.addInput(tag)
+  let _ = op.addInput(values)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func writeImageSummary<T: Numeric & TensorFlowScalar>(
+  writer: ResourceHandle,
+  step: Tensor<Int64>,
+  tag: StringTensor,
+  _ tensor: Tensor<T>,
+  badColor: Tensor<UInt8>,
+  maxImages: Int64 = 3
+) {
+  let op = TFE_Op("WriteImageSummary")
+  op.setAttr("max_images", maxImages)
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(writer)
+  let _ = op.addInput(step)
+  let _ = op.addInput(tag)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(badColor)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func writeRawProtoSummary(
+  writer: ResourceHandle,
+  step: Tensor<Int64>,
+  _ tensor: StringTensor
+) {
+  let op = TFE_Op("WriteRawProtoSummary")
+  let _ = op.addInput(writer)
+  let _ = op.addInput(step)
+  let _ = op.addInput(tensor)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func writeScalarSummary<T: Numeric & TensorFlowScalar>(
+  writer: ResourceHandle,
+  step: Tensor<Int64>,
+  tag: StringTensor,
+  value: Tensor<T>
+) {
+  let op = TFE_Op("WriteScalarSummary")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(writer)
+  let _ = op.addInput(step)
+  let _ = op.addInput(tag)
+  let _ = op.addInput(value)
+  op.execute()
+}
+
+@inlinable @inline(__always)
+public static func writeSummary<T: TensorFlowScalar>(
+  writer: ResourceHandle,
+  step: Tensor<Int64>,
+  _ tensor: Tensor<T>,
+  tag: StringTensor,
+  summaryMetadata: StringTensor
+) {
+  let op = TFE_Op("WriteSummary")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(writer)
+  let _ = op.addInput(step)
+  let _ = op.addInput(tensor)
+  let _ = op.addInput(tag)
+  let _ = op.addInput(summaryMetadata)
+  op.execute()
+}
+
+/// Returns 0 if x == 0, and x / y otherwise, elementwise.
+@inlinable @inline(__always)
+public static func xdivy<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Xdivy")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns 0 if x == 0, and x * log(y) otherwise, elementwise.
+@inlinable @inline(__always)
+public static func xlogy<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  _ y: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Xlogy")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(y)
+  return op.execute(Int(1))
+}
+
+/// Returns a tensor of zeros with the same shape and type as x.
+///
+/// - Parameter x: a tensor of type T.
+///
+/// - Output y: a tensor of the same shape and type as x but filled with zeros.
+@inlinable @inline(__always)
+public static func zerosLike<T: TensorFlowScalar>(
+  _ x: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("ZerosLike")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  return op.execute(Int(1))
+}
+
+/// Compute the Hurwitz zeta function \\(\zeta(x, q)\\).
+///
+/// The Hurwitz zeta function is defined as:
+///
+///
+/// \\(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\\)
+@inlinable @inline(__always)
+public static func zeta<T: FloatingPoint & TensorFlowScalar>(
+  _ x: Tensor<T>,
+  q: Tensor<T>
+) -> Tensor<T> {
+  let op = TFE_Op("Zeta")
+  op.setAttr("T", T.tensorFlowDataType)
+  let _ = op.addInput(x)
+  let _ = op.addInput(q)
+  return op.execute(Int(1))
+}
+
+/// Creates a dataset that zips together `input_datasets`.
+@inlinable @inline(__always)
+public static func zipDataset(
+  inputDatasets: [VariantHandle],
+  outputTypes: [TensorDataType],
+  outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let op = TFE_Op("ZipDataset")
+  op.setAttr("output_types", outputTypes)
+  op.setAttr("output_shapes", outputShapes)
+  op.setAttr("N", inputDatasets.count)
+  let _ = op.addInputList(inputDatasets)
+  return op.execute(Int(1))
+}
+
+}
diff --git a/Sources/TensorFlow/Bindings/generate_wrappers.py b/Sources/TensorFlow/Bindings/generate_wrappers.py
new file mode 100644
index 000000000..ed98c2294
--- /dev/null
+++ b/Sources/TensorFlow/Bindings/generate_wrappers.py
@@ -0,0 +1,708 @@
+# Copyright 2018 Google LLC
+#
+# 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
+#
+#     https://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.
+
+"""Generates some swift wrapper from some ops description protobuf."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import six
+import tensorflow as tf
+
+from tensorflow.core.framework import types_pb2
+from tensorflow.python.framework import c_api_util
+
+flags = tf.flags
+FLAGS = flags.FLAGS
+
+flags.DEFINE_string(
+  'api_def_path',
+  None,
+  'path to the api_def directory, e.g. tensorflow/core/api_def/base_api')
+
+flags.DEFINE_string(
+  'output_path',
+  None,
+  'path for the generated swift file')
+
+_WARNING = """// !!! THIS CODE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND !!!
+//
+"""
+
+_HEADER = """// Copyright 2018-19 Google LLC
+//
+// 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
+//
+//     https://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.
+
+"""
+
+_OUTPUT_FILE = 'RawOpsGenerated.swift'
+_RENAMED_KEYWORDS = {
+  '': 'empty',
+  'in': 'in_',
+  'var': 'var_',
+  'where': 'where_',
+  'if': 'if_',
+  'for': 'for_',
+  'while': 'while_',
+  'switch': 'switch_',
+  'protocol': 'protocol_',
+  'init': 'init_'}
+
+_TYPE_PROTOCOLS = [
+  (set(), 'TensorFlowScalar'),
+  ({types_pb2.DT_UINT8,
+    types_pb2.DT_UINT16,
+    types_pb2.DT_UINT32,
+    types_pb2.DT_UINT64}, 'UnsignedInteger & TensorFlowScalar'),
+  ({types_pb2.DT_UINT8,
+    types_pb2.DT_UINT16,
+    types_pb2.DT_UINT32,
+    types_pb2.DT_UINT64,
+    types_pb2.DT_INT8,
+    types_pb2.DT_INT16,
+    types_pb2.DT_INT32,
+    types_pb2.DT_INT64}, 'BinaryInteger & TensorFlowScalar'),
+  ({types_pb2.DT_FLOAT,
+    types_pb2.DT_DOUBLE,
+    types_pb2.DT_HALF,
+    types_pb2.DT_BFLOAT16}, 'FloatingPoint & TensorFlowScalar'),
+  ({types_pb2.DT_UINT8,
+    types_pb2.DT_UINT16,
+    types_pb2.DT_UINT32,
+    types_pb2.DT_UINT64,
+    types_pb2.DT_INT8,
+    types_pb2.DT_INT16,
+    types_pb2.DT_INT32,
+    types_pb2.DT_INT64,
+    types_pb2.DT_FLOAT,
+    types_pb2.DT_DOUBLE,
+    types_pb2.DT_HALF,
+    types_pb2.DT_BFLOAT16}, 'Numeric & TensorFlowScalar')]
+
+_SWIFTIFIED_TYPES = {
+  types_pb2.DT_FLOAT: 'Float',
+  types_pb2.DT_DOUBLE: 'Double',
+  types_pb2.DT_INT32: 'Int32',
+  types_pb2.DT_UINT8: 'UInt8',
+  types_pb2.DT_INT16: 'Int16',
+  types_pb2.DT_INT8: 'Int8',
+  types_pb2.DT_INT64: 'Int64',
+  types_pb2.DT_BOOL: 'Bool',
+  types_pb2.DT_UINT16: 'UInt16',
+  types_pb2.DT_UINT32: 'UInt32',
+  types_pb2.DT_UINT64: 'UInt64'}
+
+_SWIFTIFIED_ATTR_TYPES = {
+  'int': 'Int64',
+  'float': 'Double',
+  'bool': 'Bool',
+  'string': 'String',
+  'type': 'TensorDataType',
+  'shape': 'TensorShape?',
+  'list(int)': '[Int32]',
+  'list(float)': '[Double]',
+  'list(bool)': '[Bool]',
+  'list(string)': '[String]',
+  'list(type)': '[TensorDataType]',
+  'list(shape)': '[TensorShape?]'}
+
+_OMITTED_PARAMETER_NAMES = {
+  'x', 'y', 'a', 'b', 'input', 'tensor', 'values'}
+
+_START_COMMENT = '///'
+
+
+class UnableToGenerateCodeError(Exception):
+  def __init__(self, details):
+    self.details = details
+    super(UnableToGenerateCodeError, self).__init__()
+
+  def __str__(self):
+    return self.details
+
+
+class Op(object):
+  def __init__(self, op_def, api_def, enum_store, string_valued=False):
+    self.op_def = op_def
+    self.api_def = api_def
+    self.enum_store = enum_store
+    self.string_valued = string_valued
+    self.inferred_counts = dict()
+
+    # Collect all the input and output arguments.
+    self.input_args = [
+      Argument(arg_def, op=self)
+      for arg_def in self.op_def.input_arg]
+    self.output_args = [
+      Argument(arg_def, op=self)
+      for arg_def in self.op_def.output_arg]
+
+    # Collect all attributes.
+    self.attrs = [
+      Attribute(attr, op=self)
+      for attr in op_def.attr]
+    self.type_attrs = [
+      attr for attr in self.attrs
+      if attr.is_type_attr]
+
+  def swift_function(self):
+    return '''
+{documentation}@inlinable @inline(__always)
+public static func {name}{generics}({input_args}
+){return_type} {{
+  {body}
+}}'''.format(
+      documentation=self._swift_documentation(),
+      name=self._swift_name(),
+      generics=self._swift_generics(),
+      input_args=self._swift_input_args(),
+      return_type=self._swift_return_type(),
+      body=self._swift_body())
+
+  def _swift_documentation(self):
+    def comment_block(text, indent_level):
+      """Returns a commented block of text with some specified indentation."""
+      def indent(line_index):
+        if indent_level == 0:
+          return ''
+        if line_index:
+          return '  ' * indent_level
+        return '  ' * (indent_level - 1) + '- '
+
+      return ''.join([
+        (_START_COMMENT + ' ' + indent(line_index) + line + '\n'
+         if line else _START_COMMENT + '\n')
+        for line_index, line in enumerate(text.split('\n'))
+      ])
+
+    def append_list(doc, args, arg_type):
+      """Returns the documentation for lists of inputs/outputs/attributes."""
+      args = [arg for arg in args if arg.description]
+      if len(args) == 1:
+        block = '%s %s: %s' % (arg_type, args[0].name, args[0].description)
+        doc += _START_COMMENT + '\n'
+        doc += comment_block(block, indent_level=1)
+      elif len(args) > 1:
+        doc += '%s\n%s - %ss:\n' % (_START_COMMENT, _START_COMMENT, arg_type)
+        for arg in args:
+          block = '%s: %s' % (arg.name, arg.description)
+          doc += comment_block(block, indent_level=2)
+      return doc
+
+    doc = ''
+    if self.api_def.summary:
+      doc = comment_block(self.api_def.summary, indent_level=0)
+    if self.api_def.description:
+      doc += _START_COMMENT + '\n'
+      doc += comment_block(self.api_def.description, indent_level=0)
+    doc = append_list(doc, self.api_def.in_arg, 'Parameter')
+    doc = append_list(doc, self.api_def.attr, 'Attr')
+    doc = append_list(doc, self.api_def.out_arg, 'Output')
+    if doc and not doc.endswith('\n'):
+      doc = doc + '\n'
+    return doc
+
+  def _swift_name(self):
+    return swift_compatible_identifier(
+      self.op_def.name[0].lower() + self.op_def.name[1:])
+
+  def _swift_generics(self):
+    constraints = [
+      attr.generic_constraints(self.string_valued)
+      for attr in self.attrs]
+    constraints = [c for c in constraints if c is not None]
+    if len(constraints) == 1:
+      return '<' + ', '.join(constraints) + '>'
+    if len(constraints) > 1:
+      return '<\n    ' + ',\n    '.join(constraints) + '\n>'
+    return ''
+
+  def _swift_input_args(self):
+    args = ''
+    for arg in self.input_args:
+      args += '\n  %s: %s,' % (arg.swift_arg_name, str(arg.swift_type(self.string_valued)))
+    for attr in self.attrs:
+      if not attr.is_inferred_type_attr and not attr.is_inferred_number_attr:
+        args += '\n  %s: %s%s,' % (attr.swift_arg_name, attr.swift_type, attr.swift_default)
+    if args != '':
+      args = args[:-1]
+    return args
+
+  def _swift_return_type(self):
+    return_type = ''
+    if len(self.output_args) == 1:
+      return_type = ' -> ' + str(self.output_args[0].swift_type(self.string_valued))
+    elif len(self.output_args) > 1:
+      named_types = [
+        arg.swift_name + ': ' + str(arg.swift_type(self.string_valued))
+        for arg in self.output_args]
+      return_type = ' -> (' + ', '.join(named_types) + ')'
+    return return_type
+
+  def _swift_body(self):
+    body = 'let op = TFE_Op("{}")\n  '.format(self.op_def.name)
+    setters = []
+    for attr in self.attrs:
+      setters.append(attr.swift_setter(self.string_valued))
+    for arg in self.input_args:
+      setters.append(arg.swift_setter())
+    body += '\n  '.join(setters)
+    counts = ['Int({})'.format(arg.swift_count) for arg in self.output_args]
+    if len(self.output_args) == 0:
+      return body + '\n  op.execute()'
+    body += '\n  return op.execute({})'.format(', '.join(counts))
+    return body
+
+
+class Argument(object):
+  def __init__(self, arg_def, op):
+    self.arg_def = arg_def
+    self.op = op
+    self.is_list = arg_def.number_attr is not '' \
+                   or arg_def.type_list_attr is not ''
+
+  @property
+  def name(self):
+    return self.arg_def.name
+
+  @property
+  def swift_name(self):
+    return swift_compatible_identifier(
+      self.name[0].lower() + self.name[1:])
+
+  @property
+  def swift_arg_name(self):
+    name = self.swift_name
+    if name in _OMITTED_PARAMETER_NAMES:
+      name = '_ ' + name
+    return name
+
+  def swift_type(self, string_valued=False):
+    return self.type.swift_type(
+      string_valued=self.allows_string and string_valued)
+
+  def swift_setter(self):
+    if self.is_list:
+      return 'let _ = op.addInputList({})'.format(self.swift_name)
+    else:
+      return 'let _ = op.addInput({})'.format(self.swift_name)
+
+  @property
+  def swift_count(self):
+    number_attr = self.arg_def.number_attr
+    if number_attr and number_attr in self.op.inferred_counts:
+      return self.op.inferred_counts[number_attr]
+    if self.arg_def.type_list_attr:
+      return self.op.inferred_counts[self.arg_def.type_list_attr]
+    return '1'
+
+  @property
+  def type(self):
+    number = self.arg_def.number_attr
+    if self.arg_def.type_attr:
+      type_attr = next(
+        attr for attr in self.op.type_attrs
+        if attr.name == self.arg_def.type_attr)
+      return Type('Tensor', base_type=type_attr.swift_name, number=number)
+    if self.arg_def.type_list_attr:
+      type_attr = next(
+        attr for attr in self.op.type_attrs
+        if attr.name == self.arg_def.type_list_attr)
+      # There are never any numbered type lists.
+      return Type(type_attr.swift_name)
+    if self.arg_def.type in _SWIFTIFIED_TYPES:
+      base_type = _SWIFTIFIED_TYPES[self.arg_def.type]
+      return Type('Tensor', base_type=base_type, number=number)
+    if self.arg_def.type == types_pb2.DT_STRING:
+      return Type('Tensor', base_type='String', number=number)
+    if self.arg_def.type == types_pb2.DT_RESOURCE:
+      return Type('ResourceHandle', number=number)
+    if self.arg_def.type == types_pb2.DT_VARIANT:
+      return Type('VariantHandle', number=number)
+    raise UnableToGenerateCodeError(
+      'Unsupported type for argument "%s".' % self.name)
+
+  @property
+  def allows_string(self):
+    if self.arg_def.type_attr:
+      type_attr = next(
+        attr for attr in self.op.type_attrs
+        if attr.name == self.arg_def.type_attr)
+      return types_pb2.DT_STRING in type_attr.attr_def.allowed_values.list.type
+    return False
+
+
+class Type(object):
+  def __init__(self, kind, base_type=None, number=None):
+    self.kind = kind
+    self.base_type = base_type
+    self.number = number
+
+  @property
+  def count(self):
+    return self.number if self.number else 1
+
+  def swift_type(self, string_valued=False):
+    if self.kind == 'Tensor':
+      if self.base_type == 'String' or string_valued:
+        name = 'StringTensor'
+      else:
+        name = 'Tensor<' + self.base_type + '>'
+    elif self.kind == 'TensorHandle':
+      name = 'TensorHandle<' + self.base_type + '>'
+    elif self.kind == 'ResourceHandle':
+      name = 'ResourceHandle'
+    elif self.kind == 'VariantHandle':
+      name = 'VariantHandle'
+    else:
+      name = self.kind
+    return ('[%s]' % name) if self.number else name
+
+
+class Attribute(object):
+  """Represents information extracted from op `type` and `list(type)` attributes."""
+
+  def __init__(self, attr_def, op):
+    self.attr_def = attr_def
+    self.op = op
+    self.is_type_attr = attr_def.type in ['type', 'list(type)']
+
+    # Check whether the value of this attribute can be
+    # inferred automatically (this only applies to
+    # type-valued attributes).
+    input_args = list(op.op_def.input_arg)
+    output_args = list(op.op_def.output_arg)
+    input_arg_type_attrs = set(
+      [arg.type_attr for arg in input_args] +
+      [arg.type_list_attr for arg in input_args])
+    output_arg_type_attrs = set(
+      [arg.type_attr for arg in output_args] +
+      [arg.type_list_attr for arg in output_args])
+    arg_type_attrs = input_arg_type_attrs.union(output_arg_type_attrs)
+    self.is_inferred_type_attr = attr_def.name in arg_type_attrs
+    self.is_output_type_attr = attr_def.name in output_arg_type_attrs
+    self.is_func_attr = self.attr_def.type == 'func'
+
+    # We use this for obtaining the `_typeList` property.
+    self.input_arg = None
+    self.is_inferred_number_attr = False
+    for arg in self.op.input_args:
+      if self.attr_def.name in [arg.arg_def.type_attr,
+                                arg.arg_def.type_list_attr] or \
+         self.attr_def.name == arg.arg_def.number_attr:
+        self.input_arg = arg
+        self.is_inferred_number_attr = True
+        break
+
+    # The following properties are only relevant for
+    # non-inferred-type-valued attributes.
+    self._swift_type = ''
+    self._use_enum = False
+    if not self.is_inferred_type_attr and not self.is_func_attr:
+      if self.attr_def.type not in _SWIFTIFIED_ATTR_TYPES:
+        raise UnableToGenerateCodeError(
+          'Unsupported type for attribute "%s".'
+          % self.attr_def.name)
+
+      # Get the arg type.
+      self._swift_type = _SWIFTIFIED_ATTR_TYPES[self.attr_def.type]
+
+      # Check if the arg is an enum type.
+      self._use_enum = False
+      if self.attr_def.type == 'string':
+        allowed_values = tuple(sorted(self.attr_def.allowed_values.list.s))
+        if allowed_values:
+          self._swift_type = self.op.enum_store.maybe_add(
+            allowed_values, self.attr_def.name)
+          self._use_enum = True
+    if self.is_func_attr:
+      input_type = self.swift_name.capitalize() + 'In'
+      output_type = self.swift_name.capitalize() + 'Out'
+      self._swift_type = '({}) -> {}'.format(input_type, output_type)
+
+  @property
+  def name(self):
+    return self.attr_def.name
+
+  @property
+  def swift_name(self):
+    if self.is_inferred_type_attr:
+      return swift_compatible_identifier(
+        self.name, capitalize=True)
+    return swift_compatible_identifier(
+      self.name[0].lower() + self.name[1:])
+
+  @property
+  def swift_arg_name(self):
+    name = self.swift_name
+    if name in _OMITTED_PARAMETER_NAMES:
+      name = '_ ' + name
+    return name
+
+  @property
+  def swift_type(self):
+    return self._swift_type
+
+  @property
+  def swift_default(self):
+    def swift_float(f):
+      if f == float('inf'): return 'Double.infinity'
+      if f == float('-inf'): return '-Double.infinity'
+      return '%g' % f
+
+    if not self.is_inferred_type_attr and self.attr_def.default_value:
+      default_value = self.attr_def.default_value
+      if default_value.HasField('b'):
+        default_value = str(default_value.b).lower()
+      elif default_value.HasField('i'):
+        default_value = str(default_value.i)
+      elif default_value.HasField('f'):
+        default_value = swift_float(default_value.f)
+      elif default_value.HasField('s') and default_value.s:
+        s = str(default_value.s, encoding='utf-8')
+        default_value = '.' + swift_compatible_identifier(s.lower()) \
+          if self._use_enum else '"' + s + '"'
+      elif default_value.HasField('list'):
+        if default_value.list.i:
+          default_values = [str(s) for s in default_value.list.i]
+          default_value = '[' + ', '.join(default_values) + ']'
+        elif default_value.list.f:
+          default_values = [swift_float(s) for s in default_value.list.f]
+          default_value = '[' + ', '.join(default_values) + ']'
+        else:
+          default_value = None
+      else:
+        default_value = None
+      if default_value is not None:
+        default_value = default_value.replace("\t", "\\t")
+        return ' = ' + default_value
+    return ''
+
+  def swift_setter(self, string_valued=False):
+    # Inferred-type-valued attributes.
+    if self.is_inferred_type_attr:
+      name = self.swift_name
+      if self.input_arg is not None:
+        name = self.input_arg.swift_name
+      if self.attr_def.type == 'list(type)' or self.is_inferred_number_attr:
+        self.op.inferred_counts[self.name] = name + '._typeList.count'
+      if self.attr_def.type == 'list(type)':
+        return 'op.setAttr("{}", {}._typeList)'.format(self.name, name)
+      if string_valued and self.allows_string:
+        return 'op.setAttr("{}", TensorDataType(TF_STRING))'.format(self.name)
+      return 'op.setAttr("{}", {}.tensorFlowDataType)'.format(self.name, self.swift_name)
+
+    if self.is_inferred_number_attr:
+      # The following is used for inferring the lengths of output lists.
+      self.op.inferred_counts[self.name] = self.input_arg.swift_name + '.count'
+      return 'op.setAttr("{}", {}.count)'.format(self.name, self.input_arg.swift_name)
+    
+    if self.attr_def.type == 'int':
+      # The following is used for inferring the lengths of output lists.
+      self.op.inferred_counts[self.name] = self.swift_name
+
+    # Remaining attributes.
+    value = self.swift_name + '.cName' if self._use_enum else self.swift_name
+    return 'op.setAttr("{}", {})'.format(self.name, value)
+
+  def generic_constraints(self, string_valued):
+    # We use this for obtaining the `_typeList` property.
+    input_arg = None
+    if self.attr_def.type == 'list(type)':
+      for arg in self.op.input_args:
+        if self.attr_def.name in [arg.arg_def.type_attr,
+                                  arg.arg_def.type_list_attr]:
+          input_arg = arg
+          break
+    if self.is_func_attr:
+      input_type = self.swift_name.capitalize() + 'In'
+      output_type = self.swift_name.capitalize() + 'Out'
+      return '{}: TensorGroup,\n    {}: TensorGroup'.format(
+        input_type, output_type)
+    if not self.is_inferred_type_attr:
+      return None
+    protocol = None
+    if self.attr_def.type == 'list(type)' and input_arg is None:
+      protocol = 'TensorGroup'
+    elif self.attr_def.type == 'list(type)':
+      protocol = 'TensorArrayProtocol'
+    elif self.attr_def.type == 'type':
+      if string_valued and self.allows_string:
+        return None
+      protocol = 'TensorFlowScalar'
+      allowed_types = set(self.attr_def.allowed_values.list.type)
+      allowed_types &= set(_SWIFTIFIED_TYPES.keys())
+      for types, protocol_name in _TYPE_PROTOCOLS:
+        if allowed_types.issubset(types):
+          protocol = protocol_name
+          break
+    if protocol is not None:
+      return self.swift_name + ': ' + protocol
+    return None
+
+  @property
+  def allows_string(self):
+    return types_pb2.DT_STRING in self.attr_def.allowed_values.list.type
+
+
+def swift_compatible_identifier(s, capitalize=False):
+  """Transforms an identifier to be more swift idiomatic."""
+  if s in _RENAMED_KEYWORDS:
+    return _RENAMED_KEYWORDS[s]
+  if capitalize:
+    s = s.capitalize()
+  without_underscores = []
+  capitalize_next_char = False
+  for c in s:
+    if c == '-' or c == '_' or c == '(' or c == ')':
+      capitalize_next_char = True
+    elif capitalize_next_char:
+      capitalize_next_char = False
+      without_underscores.append(c.upper())
+    else:
+      without_underscores.append(c)
+  return ''.join(without_underscores)
+
+
+class EnumStore(object):
+  """Stores details on string attributes represented as swift enums."""
+
+  def __init__(self):
+    self._entries = {}
+    self._type_names = set()
+    self._counter = 1
+
+  def enum_codes(self):
+    """Generates the swift code for enums."""
+    codes = []
+    entries = list(six.iteritems(self._entries))
+    for allowed_values, type_name in sorted(entries, key=lambda x: x[1]):
+      allowed_values = [str(a, encoding='utf-8') for a in allowed_values]
+      codes.append(
+          # FIXME: Re-add `@_frozen` after SR-9739 is resolved.
+          # https://bugs.swift.org/browse/SR-9739
+          # '@_frozen\n' +
+          '// @_frozen // SR-9739\n' +
+          'public enum {} {{\n'.format(type_name) +
+          '\n'.join(['  case {}'.format(
+            swift_compatible_identifier(a.lower()))
+            for a in allowed_values]) +
+          '\n\n' +
+          '  @inlinable\n' +
+          '  var cName: String {\n' +
+          '    @inline(__always)\n' +
+          '    get {\n' +
+          '      switch self {\n' +
+          '\n'.join(['      case .{}: return "{}"'.format(
+            swift_compatible_identifier(a.lower()), a)
+            for a in allowed_values]) +
+          '\n' +
+          '      }\n' +
+          '    }\n' +
+          '  }\n' +
+          '}')
+    return codes
+
+  def maybe_add(self, allowed_values, attr_def_name):
+    if allowed_values in self._entries:
+      return self._entries[allowed_values]
+    type_name = swift_compatible_identifier(attr_def_name, capitalize=True)
+    while type_name in self._type_names:
+      type_name += str(self._counter)
+      self._counter += 1
+    self._type_names.add(type_name)
+    self._entries[allowed_values] = type_name
+    return type_name
+
+
+def main(argv):
+  del argv  # Unused.
+  if FLAGS.output_path is None:
+    raise ValueError('No output_path has been set')
+
+  api_def_map = c_api_util.ApiDefMap()
+
+  op_codes = []
+  enum_store = EnumStore()
+  op_names = api_def_map.op_names()
+  if FLAGS.api_def_path is not None:
+    for op_name in op_names:
+      path = os.path.join(FLAGS.api_def_path, 'api_def_%s.pbtxt' % op_name)
+      if not tf.gfile.Exists(path):
+        continue
+      with tf.gfile.Open(path, 'r') as fobj:
+        data = fobj.read()
+      try:
+        api_def_map.put_api_def(data)
+      except Exception as e:
+        print('Cannot load api def for %s: %s' % (op_name, str(e)))
+
+  num_generated = 0
+  for op_name in sorted(op_names):
+    try:
+      if op_name[0] == '_': continue
+      op_def = api_def_map.get_op_def(op_name)
+      if any(a.is_ref for a in op_def.input_arg):
+        raise UnableToGenerateCodeError('has ref-valued input')
+      if any(a.is_ref for a in op_def.output_arg):
+        raise UnableToGenerateCodeError('has ref-valued output')
+      api_def = api_def_map.get_api_def(bytes(op_name, 'utf8'))
+
+      # It would be nicer to handle `StringTensor` in a more
+      # general way by having `String` conform to `TensorFlowScalar`.
+      default_op = Op(op_def, api_def, enum_store, string_valued=False)
+      string_valued_op = Op(op_def, api_def, enum_store, string_valued=True)
+      default_code = default_op.swift_function()
+      string_valued_code = string_valued_op.swift_function()
+      op_codes.append(default_code)
+      if string_valued_code != default_code:
+        op_codes.append(string_valued_code)
+      num_generated += 1
+    except UnableToGenerateCodeError as e:
+      print('Cannot generate code for %s: %s' % (op_name, e.details))
+  print('Generated code for %d/%d ops.' % (num_generated, len(op_names)))
+
+  version_codes = [
+      'static let generatedTensorFlowVersion = "%s"' % tf.__version__,
+      'static let generatedTensorFlowGitVersion = "%s"' % tf.__git_version__]
+
+  swift_code = (
+      _WARNING +
+      _HEADER +
+      'import CTensorFlow\n\n' +
+      '\npublic enum Raw {\n\n' +
+      '\n'.join(version_codes) +
+      '\n\n' +
+      '\n\n'.join(enum_store.enum_codes()) +
+      '\n\n' +
+      '\n'.join(op_codes) +
+      '\n\n}\n')
+  with tf.gfile.Open(FLAGS.output_path, 'w') as f:
+    f.write(swift_code)
+
+
+if __name__ == '__main__':
+  tf.app.run(main)

From 9527b48c14150898611b0418c4201b8b3a23ab27 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sat, 11 May 2019 18:18:18 -0400
Subject: [PATCH 24/55] Minor edit to make tests pass.

---
 Sources/TensorFlow/Core/Utilities.swift | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Sources/TensorFlow/Core/Utilities.swift b/Sources/TensorFlow/Core/Utilities.swift
index 5d085e534..31c1f7b83 100644
--- a/Sources/TensorFlow/Core/Utilities.swift
+++ b/Sources/TensorFlow/Core/Utilities.swift
@@ -158,17 +158,17 @@ internal func writeContents(of buffer: UnsafePointer<TF_Buffer>, toFile path: St
 /// This is a generic host-only op that hides the details of its impl in the SIL code. This makes 
 /// reading/writing SIL based compiler unit tests simple.
 @usableFromInline @inline(never)
-internal func _hostOp<T>(_ x: T) {
+public func _hostOp<T>(_ x: T) {
     print(x)
 }
 
 @usableFromInline @inline(never)
-internal func _hostOp<Scalar>(_ x: Tensor<Scalar>) {
+public func _hostOp<Scalar>(_ x: Tensor<Scalar>) {
     print(x)
 }
 
 @usableFromInline @inline(never)
-internal func _hostOp<Scalar : TensorFlowScalar>(_ x: TensorHandle<Scalar>) {
+public func _hostOp<Scalar : TensorFlowScalar>(_ x: TensorHandle<Scalar>) {
     print(Tensor(handle: x))
 }
 
@@ -176,14 +176,14 @@ internal func _hostOp<Scalar : TensorFlowScalar>(_ x: TensorHandle<Scalar>) {
 ///
 /// TODO: Remove these helper APIs, when we have a better shape inference/propagation design.
 @usableFromInline @inline(__always)
-internal func _scalarTensorWithShape<Scalar: TensorFlowScalar>(
+public func _scalarTensorWithShape<Scalar: TensorFlowScalar>(
     _ x: Tensor<Scalar>
 ) -> Tensor<Scalar> {
     return Raw.identity(x)
 }
 
 @usableFromInline @inline(__always)
-internal func _addScalarTensorsWithShape<Scalar: TensorFlowNumeric>(
+public func _addScalarTensorsWithShape<Scalar: TensorFlowNumeric>(
     _ x: Tensor<Scalar>,
     _ y: Tensor<Scalar>
 ) -> Tensor<Scalar> {

From 7f368a8a6579f428c513e7fa2b39e2d5948debc9 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sat, 11 May 2019 18:19:38 -0400
Subject: [PATCH 25/55] Minor edit to make tests pass.

---
 Sources/TensorFlow/Core/Utilities.swift | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Sources/TensorFlow/Core/Utilities.swift b/Sources/TensorFlow/Core/Utilities.swift
index 31c1f7b83..83358de14 100644
--- a/Sources/TensorFlow/Core/Utilities.swift
+++ b/Sources/TensorFlow/Core/Utilities.swift
@@ -157,17 +157,17 @@ internal func writeContents(of buffer: UnsafePointer<TF_Buffer>, toFile path: St
 
 /// This is a generic host-only op that hides the details of its impl in the SIL code. This makes 
 /// reading/writing SIL based compiler unit tests simple.
-@usableFromInline @inline(never)
+@inlinable @inline(never)
 public func _hostOp<T>(_ x: T) {
     print(x)
 }
 
-@usableFromInline @inline(never)
+@inlinable @inline(never)
 public func _hostOp<Scalar>(_ x: Tensor<Scalar>) {
     print(x)
 }
 
-@usableFromInline @inline(never)
+@inlinable @inline(never)
 public func _hostOp<Scalar : TensorFlowScalar>(_ x: TensorHandle<Scalar>) {
     print(Tensor(handle: x))
 }
@@ -175,14 +175,14 @@ public func _hostOp<Scalar : TensorFlowScalar>(_ x: TensorHandle<Scalar>) {
 /// Some TPU ops (e.g. infeed/outfeed) require tensor shape info, which the APIs below can provide.
 ///
 /// TODO: Remove these helper APIs, when we have a better shape inference/propagation design.
-@usableFromInline @inline(__always)
+@inlinable @inline(__always)
 public func _scalarTensorWithShape<Scalar: TensorFlowScalar>(
     _ x: Tensor<Scalar>
 ) -> Tensor<Scalar> {
     return Raw.identity(x)
 }
 
-@usableFromInline @inline(__always)
+@inlinable @inline(__always)
 public func _addScalarTensorsWithShape<Scalar: TensorFlowNumeric>(
     _ x: Tensor<Scalar>,
     _ y: Tensor<Scalar>

From 1e228f111906f6bc72c4f933554f49d807f49e8b Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sat, 11 May 2019 18:25:03 -0400
Subject: [PATCH 26/55] Minor edit to make tests pass.

---
 Sources/TensorFlow/Core/Runtime.swift | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index 70878a215..cdda7157d 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -1826,9 +1826,9 @@ internal func _TFCGetTensorGroupCHandleCount<T : TensorGroup>(
   return T._tensorHandleCount
 }
 
-@usableFromInline
+@inlinable
 @_silgen_name("_swift_tfc_CreateTensorHandleFromC")
-internal func _TFCCreateTensorHandleFromC(
+public func _TFCCreateTensorHandleFromC(
   _ cHandle: CTensorHandle
 ) -> _AnyTensorHandle {
   let dtype = TFE_TensorHandleDataType(cHandle)

From 3a90c9403ff903cf89c01d2892f8a18a73556fe6 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 12 May 2019 11:51:08 -0400
Subject: [PATCH 27/55] Integrated changes from apple/swift#24719.

---
 .../TensorFlow/Bindings/EagerExecution.swift  |   74 +-
 .../Bindings/EagerExecution.swift.gyb         |   56 +-
 .../TensorFlow/Bindings/RawOpsGenerated.swift | 2249 ++++++++---------
 .../TensorFlow/Bindings/generate_wrappers.py  |    3 +-
 Sources/TensorFlow/Core/ArrayOps.swift        |    4 +-
 Sources/TensorFlow/Core/DataTypes.swift       |  228 --
 Sources/TensorFlow/Core/Helpers.swift         |   76 -
 Sources/TensorFlow/Core/ShapedArray.swift     |    8 +-
 Sources/TensorFlow/Core/StringTensor.swift    |   73 +-
 Sources/TensorFlow/Core/Tensor.swift          |  126 +-
 Sources/TensorFlow/Core/TensorHandle.swift    |  120 -
 Sources/TensorFlow/Core/TensorProtocol.swift  |   25 -
 Sources/TensorFlow/Core/TensorShape.swift     |   54 +-
 Sources/TensorFlow/Initializers.swift         |   32 +-
 Sources/TensorFlow/Operators/Comparison.swift |   56 +-
 Sources/TensorFlow/Operators/Dataset.swift    |   34 +-
 Sources/TensorFlow/Operators/Math.swift       |   32 +-
 17 files changed, 1387 insertions(+), 1863 deletions(-)

diff --git a/Sources/TensorFlow/Bindings/EagerExecution.swift b/Sources/TensorFlow/Bindings/EagerExecution.swift
index 7c25f2bb7..a7d13835f 100644
--- a/Sources/TensorFlow/Bindings/EagerExecution.swift
+++ b/Sources/TensorFlow/Bindings/EagerExecution.swift
@@ -25,34 +25,34 @@ internal struct TFE_Op {
   @usableFromInline internal let status: CTFStatus
   @usableFromInline internal let op: CTFEOp
 
-  @inlinable @inline(__always)
+  @inlinable
   internal init(_ name: String) {
     self.status = TF_NewStatus()
     self.op = TFE_NewOp(_ExecutionContext.global.eagerContext, name, status)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func addInput(_ inputHandle: _AnyTensorHandle) -> Int {
     TFE_OpAddInput(op, inputHandle._cTensorHandle, status)
     checkOk(status)
     return 1
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func addInput<Scalar: TensorFlowScalar>(_ input: Tensor<Scalar>) -> Int {
     TFE_OpAddInput(op, input.handle._cTensorHandle, status)
     checkOk(status)
     return 1
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func addInput(_ input: StringTensor) -> Int {
     TFE_OpAddInput(op, input.handle._cTensorHandle, status)
     checkOk(status)
     return 1
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func addInputList<T: TensorArrayProtocol>(_ input: T) -> Int {
     let count = input._tensorHandleCount
     var buffer = UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: Int(count))
@@ -64,37 +64,37 @@ internal struct TFE_Op {
     return Int(count)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: Bool) {
     TFE_OpSetAttrBool(op, name, value ? 1 : 0)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: Int) {
     TFE_OpSetAttrInt(op, name, Int64(value))
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: Int32) {
     TFE_OpSetAttrInt(op, name, Int64(value))
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: Int64) {
     TFE_OpSetAttrInt(op, name, value)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: Float) {
     TFE_OpSetAttrFloat(op, name, value)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: Double) {
     TFE_OpSetAttrFloat(op, name, Float(value))
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: String) {
     value.utf8CString.withUnsafeBufferPointer { buffer in
       // utf8CString is null-terminated; TFE_OpSetAttrString wants
@@ -103,12 +103,12 @@ internal struct TFE_Op {
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: TensorDataType) {
     TFE_OpSetAttrType(op, name, value._cDataType)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: TensorShape) {
     let dimensions: [Int64] = value.dimensions.map(Int64.init)
     dimensions.withUnsafeBufferPointer { buffer in
@@ -116,7 +116,7 @@ internal struct TFE_Op {
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: TensorShape?) {
     guard let shape = value else {
       TFE_OpSetAttrShape(op, name, nil, -1, status)
@@ -125,43 +125,43 @@ internal struct TFE_Op {
     setAttr(name, shape)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [Bool]) {
     value.map({ $0 ? UInt8(1) : UInt8(0) }).withUnsafeBufferPointer { buffer in
       TFE_OpSetAttrBoolList(op, name, buffer.baseAddress, Int32(buffer.count))
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [Int]) {
     setAttr(name, value.map(Int64.init))
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [Int32]) {
     setAttr(name, value.map(Int64.init))
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [Int64]) {
     value.withUnsafeBufferPointer { buffer in
       TFE_OpSetAttrIntList(op, name, buffer.baseAddress, Int32(buffer.count))
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [Float]) {
     value.withUnsafeBufferPointer { buffer in
       TFE_OpSetAttrFloatList(op, name, buffer.baseAddress, Int32(buffer.count))
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [Double]) {
     setAttr(name, value.map(Float.init))
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [String]) {
     // Collect all the strings' utf8 bytes into a single array so that we can
     // address all the strings with a single
@@ -196,7 +196,7 @@ internal struct TFE_Op {
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [TensorDataType]) {
     value.withUnsafeBufferPointer { buffer in
       buffer.withMemoryRebound(to: TF_DataType.self) { reboundBuffer in
@@ -205,7 +205,7 @@ internal struct TFE_Op {
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [TensorShape]) {
     let flattenedDims = value.flatMap { $0.dimensions.map(Int64.init) }
     let ranks = value.map { Int32($0.rank) }
@@ -228,7 +228,7 @@ internal struct TFE_Op {
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [TensorShape?]) {
     let flattenedDims = value.flatMap { (tensorShapeOpt) -> [Int64] in
       if let tensorShape = tensorShapeOpt {
@@ -256,7 +256,7 @@ internal struct TFE_Op {
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr<In: TensorGroup, Out: TensorGroup>(_ name: String, _ value: (In) -> Out) {
     _tffunc(value).utf8CString.withUnsafeBufferPointer { buffer in
       // utf8CString is null-terminated; TFE_OpSetAttrFunctionName wants
@@ -270,7 +270,7 @@ internal struct TFE_Op {
   /// TensorFlow eager op object not being freed. If called more than once, then a SEGFAULT may
   /// occur due to trying to execute a TensorFlow eager op that has already been freed.
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute() {
     var count: Int32 = 0
     var unused: CTensorHandle?
@@ -282,7 +282,7 @@ internal struct TFE_Op {
     TF_DeleteStatus(status)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute<T0 : TensorArrayProtocol>(
     _ count0: Int
   ) -> (T0) {
@@ -302,7 +302,7 @@ internal struct TFE_Op {
     return result
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int
@@ -325,7 +325,7 @@ internal struct TFE_Op {
     return result
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
@@ -351,7 +351,7 @@ internal struct TFE_Op {
     return result
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
@@ -380,7 +380,7 @@ internal struct TFE_Op {
     return result
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
@@ -412,7 +412,7 @@ internal struct TFE_Op {
     return result
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
@@ -447,7 +447,7 @@ internal struct TFE_Op {
     return result
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol, T6 : TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
@@ -485,7 +485,7 @@ internal struct TFE_Op {
     return result
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol, T6 : TensorArrayProtocol, T7 : TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
@@ -526,7 +526,7 @@ internal struct TFE_Op {
     return result
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol, T6 : TensorArrayProtocol, T7 : TensorArrayProtocol, T8 : TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
@@ -570,7 +570,7 @@ internal struct TFE_Op {
     return result
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol, T6 : TensorArrayProtocol, T7 : TensorArrayProtocol, T8 : TensorArrayProtocol, T9 : TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
diff --git a/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb b/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
index 826f35f2c..1eb586132 100644
--- a/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
+++ b/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
@@ -25,34 +25,34 @@ internal struct TFE_Op {
   @usableFromInline internal let status: CTFStatus
   @usableFromInline internal let op: CTFEOp
 
-  @inlinable @inline(__always)
+  @inlinable
   internal init(_ name: String) {
     self.status = TF_NewStatus()
     self.op = TFE_NewOp(_ExecutionContext.global.eagerContext, name, status)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func addInput(_ inputHandle: _AnyTensorHandle) -> Int {
     TFE_OpAddInput(op, inputHandle._cTensorHandle, status)
     checkOk(status)
     return 1
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func addInput<Scalar: TensorFlowScalar>(_ input: Tensor<Scalar>) -> Int {
     TFE_OpAddInput(op, input.handle._cTensorHandle, status)
     checkOk(status)
     return 1
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func addInput(_ input: StringTensor) -> Int {
     TFE_OpAddInput(op, input.handle._cTensorHandle, status)
     checkOk(status)
     return 1
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func addInputList<T: TensorArrayProtocol>(_ input: T) -> Int {
     let count = input._tensorHandleCount
     var buffer = UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: Int(count))
@@ -64,37 +64,37 @@ internal struct TFE_Op {
     return Int(count)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: Bool) {
     TFE_OpSetAttrBool(op, name, value ? 1 : 0)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: Int) {
     TFE_OpSetAttrInt(op, name, Int64(value))
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: Int32) {
     TFE_OpSetAttrInt(op, name, Int64(value))
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: Int64) {
     TFE_OpSetAttrInt(op, name, value)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: Float) {
     TFE_OpSetAttrFloat(op, name, value)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: Double) {
     TFE_OpSetAttrFloat(op, name, Float(value))
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: String) {
     value.utf8CString.withUnsafeBufferPointer { buffer in
       // utf8CString is null-terminated; TFE_OpSetAttrString wants
@@ -103,12 +103,12 @@ internal struct TFE_Op {
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: TensorDataType) {
     TFE_OpSetAttrType(op, name, value._cDataType)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: TensorShape) {
     let dimensions: [Int64] = value.dimensions.map(Int64.init)
     dimensions.withUnsafeBufferPointer { buffer in
@@ -116,7 +116,7 @@ internal struct TFE_Op {
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: TensorShape?) {
     guard let shape = value else {
       TFE_OpSetAttrShape(op, name, nil, -1, status)
@@ -125,43 +125,43 @@ internal struct TFE_Op {
     setAttr(name, shape)
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [Bool]) {
     value.map({ $0 ? UInt8(1) : UInt8(0) }).withUnsafeBufferPointer { buffer in
       TFE_OpSetAttrBoolList(op, name, buffer.baseAddress, Int32(buffer.count))
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [Int]) {
     setAttr(name, value.map(Int64.init))
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [Int32]) {
     setAttr(name, value.map(Int64.init))
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [Int64]) {
     value.withUnsafeBufferPointer { buffer in
       TFE_OpSetAttrIntList(op, name, buffer.baseAddress, Int32(buffer.count))
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [Float]) {
     value.withUnsafeBufferPointer { buffer in
       TFE_OpSetAttrFloatList(op, name, buffer.baseAddress, Int32(buffer.count))
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [Double]) {
     setAttr(name, value.map(Float.init))
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [String]) {
     // Collect all the strings' utf8 bytes into a single array so that we can
     // address all the strings with a single
@@ -196,7 +196,7 @@ internal struct TFE_Op {
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [TensorDataType]) {
     value.withUnsafeBufferPointer { buffer in
       buffer.withMemoryRebound(to: TF_DataType.self) { reboundBuffer in
@@ -205,7 +205,7 @@ internal struct TFE_Op {
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [TensorShape]) {
     let flattenedDims = value.flatMap { $0.dimensions.map(Int64.init) }
     let ranks = value.map { Int32($0.rank) }
@@ -228,7 +228,7 @@ internal struct TFE_Op {
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr(_ name: String, _ value: [TensorShape?]) {
     let flattenedDims = value.flatMap { (tensorShapeOpt) -> [Int64] in
       if let tensorShape = tensorShapeOpt {
@@ -256,7 +256,7 @@ internal struct TFE_Op {
     }
   }
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func setAttr<In: TensorGroup, Out: TensorGroup>(_ name: String, _ value: (In) -> Out) {
     _tffunc(value).utf8CString.withUnsafeBufferPointer { buffer in
       // utf8CString is null-terminated; TFE_OpSetAttrFunctionName wants
@@ -270,7 +270,7 @@ internal struct TFE_Op {
   /// TensorFlow eager op object not being freed. If called more than once, then a SEGFAULT may
   /// occur due to trying to execute a TensorFlow eager op that has already been freed.
 
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute() {
     var count: Int32 = 0
     var unused: CTensorHandle?
@@ -283,7 +283,7 @@ internal struct TFE_Op {
   }
 
 %for n in range(1, 10 + 1):
-  @inlinable @inline(__always)
+  @inlinable
   internal func execute<${", ".join(["T" + str(i) + " : TensorArrayProtocol" for i in range(n)])}>(
     ${",\n    ".join(["_ count" + str(i) + ": Int" for i in range(n)])}
   ) -> (${", ".join(["T" + str(i) for i in range(n)])}) {
diff --git a/Sources/TensorFlow/Bindings/RawOpsGenerated.swift b/Sources/TensorFlow/Bindings/RawOpsGenerated.swift
index 36ddb6665..78b4728b7 100644
--- a/Sources/TensorFlow/Bindings/RawOpsGenerated.swift
+++ b/Sources/TensorFlow/Bindings/RawOpsGenerated.swift
@@ -29,7 +29,6 @@ public enum A {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .apples: return "apples"
@@ -46,7 +45,6 @@ public enum DataFormat {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .nchw: return "NCHW"
@@ -63,7 +61,6 @@ public enum DataFormat1 {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .ncdhw: return "NCDHW"
@@ -81,7 +78,6 @@ public enum DataFormat4 {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .nchw: return "NCHW"
@@ -99,7 +95,6 @@ public enum DensityUnit {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .cm: return "cm"
@@ -116,7 +111,6 @@ public enum Direction {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .bidirectional: return "bidirectional"
@@ -134,7 +128,6 @@ public enum Errors {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .ignore: return "ignore"
@@ -152,7 +145,6 @@ public enum FinalOp {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .div: return "Div"
@@ -170,7 +162,6 @@ public enum Format {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .empty: return ""
@@ -189,7 +180,6 @@ public enum InputMode {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .autoSelect: return "auto_select"
@@ -210,7 +200,6 @@ public enum LossType {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .hingeLoss: return "hinge_loss"
@@ -232,7 +221,6 @@ public enum MergeOp {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .add: return "Add"
@@ -251,7 +239,6 @@ public enum Method {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .bilinear: return "bilinear"
@@ -267,7 +254,6 @@ public enum Method3 {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .bilinear: return "bilinear"
@@ -284,7 +270,6 @@ public enum Mode {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .minCombined: return "MIN_COMBINED"
@@ -302,7 +287,6 @@ public enum Mode5 {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .reflect: return "REFLECT"
@@ -320,7 +304,6 @@ public enum OutputEncoding {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .utf16Be: return "UTF-16-BE"
@@ -338,7 +321,6 @@ public enum Padding {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .same: return "SAME"
@@ -356,7 +338,6 @@ public enum Padding2 {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .explicit: return "EXPLICIT"
@@ -376,7 +357,6 @@ public enum Reduction {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .max: return "max"
@@ -397,7 +377,6 @@ public enum RnnMode {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .gru: return "gru"
@@ -416,7 +395,6 @@ public enum RoundMode {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .halfToEven: return "HALF_TO_EVEN"
@@ -433,7 +411,6 @@ public enum RoundMode6 {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .halfAwayFromZero: return "HALF_AWAY_FROM_ZERO"
@@ -449,7 +426,6 @@ public enum SplitType {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .inequality: return "inequality"
@@ -465,7 +441,6 @@ public enum Unit {
 
   @inlinable
   var cName: String {
-    @inline(__always)
     get {
       switch self {
       case .byte: return "BYTE"
@@ -476,7 +451,7 @@ public enum Unit {
 }
 
 
-@inlinable @inline(__always)
+@inlinable
 public static func a(
 ) -> Tensor<Float> {
   let op = TFE_Op("A")
@@ -492,7 +467,7 @@ public static func a(
 /// Returns nothing but an exception.
 ///
 /// - Attr error_msg: A string which is the message associated with the exception.
-@inlinable @inline(__always)
+@inlinable
 public static func abort(
   errorMsg: String,
   exitWithoutError: Bool = false
@@ -508,7 +483,7 @@ public static func abort(
 /// Given a tensor `x`, this operation returns a tensor containing the absolute
 /// value of each element in `x`. For example, if x is an input element and y is
 /// an output element, this operation computes \\(y = |x|\\).
-@inlinable @inline(__always)
+@inlinable
 public static func abs<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -532,7 +507,7 @@ public static func abs<T: Numeric & TensorFlowScalar>(
 /// - Parameter inputs: A list of `Tensor` objects, each with same shape and type.
 ///
 /// - Attr shape: Shape of elements of `inputs`.
-@inlinable @inline(__always)
+@inlinable
 public static func accumulateNV2<T: Numeric & TensorFlowScalar>(
   inputs: [Tensor<T>],
   shape: TensorShape?
@@ -546,7 +521,7 @@ public static func accumulateNV2<T: Numeric & TensorFlowScalar>(
 }
 
 /// Computes acos of x element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func acos<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -557,7 +532,7 @@ public static func acos<T: Numeric & TensorFlowScalar>(
 }
 
 /// Computes inverse hyperbolic cosine of x element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func acosh<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -571,7 +546,7 @@ public static func acosh<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func add<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -587,7 +562,7 @@ public static func add<T: Numeric & TensorFlowScalar>(
 ///
 /// *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func add(
   _ x: StringTensor,
   _ y: StringTensor
@@ -638,7 +613,7 @@ public static func add(
 ///
 /// - Output sparse_handles: 1-D.  The handles of the `SparseTensor` now stored in the
 ///   `SparseTensorsMap`.  Shape: `[N]`.
-@inlinable @inline(__always)
+@inlinable
 public static func addManySparseToTensorsMap<T: TensorFlowScalar>(
   sparseIndices: Tensor<Int64>,
   sparseValues: Tensor<T>,
@@ -659,7 +634,7 @@ public static func addManySparseToTensorsMap<T: TensorFlowScalar>(
 /// Add all input tensors element wise.
 ///
 /// - Parameter inputs: Must all be the same size and shape.
-@inlinable @inline(__always)
+@inlinable
 public static func addN<T: Numeric & TensorFlowScalar>(
   inputs: [Tensor<T>]
 ) -> Tensor<T> {
@@ -699,7 +674,7 @@ public static func addN<T: Numeric & TensorFlowScalar>(
 ///
 /// - Output sparse_handle: 0-D.  The handle of the `SparseTensor` now stored in the
 ///   `SparseTensorsMap`.
-@inlinable @inline(__always)
+@inlinable
 public static func addSparseToTensorsMap<T: TensorFlowScalar>(
   sparseIndices: Tensor<Int64>,
   sparseValues: Tensor<T>,
@@ -721,7 +696,7 @@ public static func addSparseToTensorsMap<T: TensorFlowScalar>(
 ///
 /// *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func addV2<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -734,7 +709,7 @@ public static func addV2<T: Numeric & TensorFlowScalar>(
 }
 
 /// Deprecated. Disallowed in GraphDef version >= 2.
-@inlinable @inline(__always)
+@inlinable
 public static func adjustContrast<T: Numeric & TensorFlowScalar>(
   images: Tensor<T>,
   contrastFactor: Tensor<Float>,
@@ -767,7 +742,7 @@ public static func adjustContrast<T: Numeric & TensorFlowScalar>(
 ///   - contrast_factor: A float multiplier for adjusting contrast.
 ///
 /// - Output output: The contrast-adjusted image or images.
-@inlinable @inline(__always)
+@inlinable
 public static func adjustContrastv2<T: FloatingPoint & TensorFlowScalar>(
   images: Tensor<T>,
   contrastFactor: Tensor<Float>
@@ -793,7 +768,7 @@ public static func adjustContrastv2<T: FloatingPoint & TensorFlowScalar>(
 ///   - delta: A float delta to add to the hue.
 ///
 /// - Output output: The hue-adjusted image or images.
-@inlinable @inline(__always)
+@inlinable
 public static func adjustHue<T: FloatingPoint & TensorFlowScalar>(
   images: Tensor<T>,
   delta: Tensor<Float>
@@ -819,7 +794,7 @@ public static func adjustHue<T: FloatingPoint & TensorFlowScalar>(
 ///   - scale: A float scale to add to the saturation.
 ///
 /// - Output output: The hue-adjusted image or images.
-@inlinable @inline(__always)
+@inlinable
 public static func adjustSaturation<T: FloatingPoint & TensorFlowScalar>(
   images: Tensor<T>,
   scale: Tensor<Float>
@@ -846,7 +821,7 @@ public static func adjustSaturation<T: FloatingPoint & TensorFlowScalar>(
 /// - Attr keep_dims: If true, retain reduced dimensions with length 1.
 ///
 /// - Output output: The reduced tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func all<Tidx: BinaryInteger & TensorFlowScalar>(
   _ input: Tensor<Bool>,
   reductionIndices: Tensor<Tidx>,
@@ -896,7 +871,7 @@ public static func all<Tidx: BinaryInteger & TensorFlowScalar>(
 ///     candidate representing the number of times the candidate is expected
 ///     to occur in a batch of sampled candidates.  If unique=true, then this is a
 ///     probability.
-@inlinable @inline(__always)
+@inlinable
 public static func allCandidateSampler(
   trueClasses: Tensor<Int64>,
   numTrue: Int64,
@@ -948,7 +923,7 @@ public static func allCandidateSampler(
 ///     size(group_assignment.get_shape()[1])
 ///
 /// - Output output: The exchanged result.
-@inlinable @inline(__always)
+@inlinable
 public static func allToAll<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   groupAssignment: Tensor<Int32>,
@@ -985,7 +960,7 @@ public static func allToAll<T: TensorFlowScalar>(
 /// @compatibility(numpy)
 /// Equivalent to np.angle.
 /// @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func angle<
     T: TensorFlowScalar,
     Tout: FloatingPoint & TensorFlowScalar
@@ -1005,7 +980,7 @@ public static func angle<
 ///   "IteratorGetNext" op. In contrast to Iterator, AnonymousIterator prevents
 ///   resource sharing by name, and does not keep a reference to the resource
 ///   container.
-@inlinable @inline(__always)
+@inlinable
 public static func anonymousIterator(
   outputTypes: [TensorDataType],
   outputShapes: [TensorShape?]
@@ -1024,7 +999,7 @@ public static func anonymousIterator(
 ///     resource sharing by name, and does not keep a reference to the resource
 ///     container.
 ///   - deleter: A variant deleter that should be passed into the op that deletes the iterator.
-@inlinable @inline(__always)
+@inlinable
 public static func anonymousIteratorV2(
   outputTypes: [TensorDataType],
   outputShapes: [TensorShape?]
@@ -1050,7 +1025,7 @@ public static func anonymousIteratorV2(
 /// - Attr keep_dims: If true, retain reduced dimensions with length 1.
 ///
 /// - Output output: The reduced tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func any<Tidx: BinaryInteger & TensorFlowScalar>(
   _ input: Tensor<Bool>,
   reductionIndices: Tensor<Tidx>,
@@ -1065,7 +1040,7 @@ public static func any<Tidx: BinaryInteger & TensorFlowScalar>(
 }
 
 /// Returns the truth value of abs(x-y) < tolerance element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func approximateEqual<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>,
@@ -1096,7 +1071,7 @@ public static func approximateEqual<T: Numeric & TensorFlowScalar>(
 /// - Parameter dimension: int32 or int64, must be in the range `[-rank(input), rank(input))`.
 ///   Describes which dimension of the input Tensor to reduce across. For vectors,
 ///   use dimension = 0.
-@inlinable @inline(__always)
+@inlinable
 public static func argMax<
     T: Numeric & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar,
@@ -1131,7 +1106,7 @@ public static func argMax<
 /// - Parameter dimension: int32 or int64, must be in the range `[-rank(input), rank(input))`.
 ///   Describes which dimension of the input Tensor to reduce across. For vectors,
 ///   use dimension = 0.
-@inlinable @inline(__always)
+@inlinable
 public static func argMin<
     T: Numeric & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar,
@@ -1164,7 +1139,7 @@ public static func argMin<
 ///     Only used if width > -1.
 ///   - fill: The value to pad if width > -1.  If empty, pads with spaces.
 ///     Another typical value is '0'.  String cannot be longer than 1 character.
-@inlinable @inline(__always)
+@inlinable
 public static func asString<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   precision: Int64 = -1,
@@ -1202,7 +1177,7 @@ public static func asString<T: TensorFlowScalar>(
 /// tf.math.asin(y) # [1.047, 0.785] = x
 /// ```
 ///
-@inlinable @inline(__always)
+@inlinable
 public static func asin<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -1213,7 +1188,7 @@ public static func asin<T: Numeric & TensorFlowScalar>(
 }
 
 /// Computes inverse hyperbolic sine of x element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func asinh<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -1233,7 +1208,7 @@ public static func asinh<T: FloatingPoint & TensorFlowScalar>(
 ///   - data: The tensors to print out when condition is false.
 ///
 /// - Attr summarize: Print this many entries of each tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func assert<T: TensorArrayProtocol>(
   condition: Tensor<Bool>,
   data: T,
@@ -1257,7 +1232,7 @@ public static func assert<T: TensorArrayProtocol>(
 ///   - value: the value by which the variable will be incremented.
 ///
 /// - Attr dtype: the dtype of the value.
-@inlinable @inline(__always)
+@inlinable
 public static func assignAddVariableOp<Dtype: TensorFlowScalar>(
   resource: ResourceHandle,
   value: Tensor<Dtype>
@@ -1279,7 +1254,7 @@ public static func assignAddVariableOp<Dtype: TensorFlowScalar>(
 ///   - value: the value by which the variable will be incremented.
 ///
 /// - Attr dtype: the dtype of the value.
-@inlinable @inline(__always)
+@inlinable
 public static func assignSubVariableOp<Dtype: TensorFlowScalar>(
   resource: ResourceHandle,
   value: Tensor<Dtype>
@@ -1301,7 +1276,7 @@ public static func assignSubVariableOp<Dtype: TensorFlowScalar>(
 ///   - value: the value to set the new tensor to use.
 ///
 /// - Attr dtype: the dtype of the value.
-@inlinable @inline(__always)
+@inlinable
 public static func assignVariableOp<Dtype: TensorFlowScalar>(
   resource: ResourceHandle,
   value: Tensor<Dtype>
@@ -1331,7 +1306,7 @@ public static func assignVariableOp<Dtype: TensorFlowScalar>(
 /// tf.math.atan(y) # [1.047, 0.785] = x
 /// ```
 ///
-@inlinable @inline(__always)
+@inlinable
 public static func atan<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -1348,7 +1323,7 @@ public static func atan<T: Numeric & TensorFlowScalar>(
 /// and
 /// \[ y = r \sin(\theta) \]
 /// where \(r = \sqrt(x^2 + y^2) \).
-@inlinable @inline(__always)
+@inlinable
 public static func atan2<T: FloatingPoint & TensorFlowScalar>(
   _ y: Tensor<T>,
   _ x: Tensor<T>
@@ -1361,7 +1336,7 @@ public static func atan2<T: FloatingPoint & TensorFlowScalar>(
 }
 
 /// Computes inverse hyperbolic tangent of x element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func atanh<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -1371,7 +1346,7 @@ public static func atanh<T: FloatingPoint & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attr(
   _ a: Int64
 ) {
@@ -1380,7 +1355,7 @@ public static func attr(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrBool(
   _ a: Bool
 ) {
@@ -1389,7 +1364,7 @@ public static func attrBool(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrBoolList(
   _ a: [Bool]
 ) {
@@ -1398,7 +1373,7 @@ public static func attrBoolList(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrDefault(
   _ a: String = "banana"
 ) {
@@ -1407,7 +1382,7 @@ public static func attrDefault(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrEmptyListDefault(
   _ a: [Double]
 ) {
@@ -1416,7 +1391,7 @@ public static func attrEmptyListDefault(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrEnum(
   _ a: A
 ) {
@@ -1425,7 +1400,7 @@ public static func attrEnum(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrEnumList(
   _ a: [String]
 ) {
@@ -1434,7 +1409,7 @@ public static func attrEnumList(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrFloat(
   _ a: Double
 ) {
@@ -1443,7 +1418,7 @@ public static func attrFloat(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrListDefault(
   _ a: [Int32] = [5, 15]
 ) {
@@ -1452,7 +1427,7 @@ public static func attrListDefault(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrListMin(
   _ a: [Int32]
 ) {
@@ -1461,7 +1436,7 @@ public static func attrListMin(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrListTypeDefault<T: TensorFlowScalar>(
   _ a: [Tensor<T>],
   _ b: [Tensor<T>]
@@ -1474,7 +1449,7 @@ public static func attrListTypeDefault<T: TensorFlowScalar>(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrMin(
   _ a: Int64
 ) {
@@ -1483,7 +1458,7 @@ public static func attrMin(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrPartialShape(
   _ a: TensorShape?
 ) {
@@ -1492,7 +1467,7 @@ public static func attrPartialShape(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrPartialShapeList(
   _ a: [TensorShape?]
 ) {
@@ -1501,7 +1476,7 @@ public static func attrPartialShapeList(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrShape(
   _ a: TensorShape?
 ) {
@@ -1510,7 +1485,7 @@ public static func attrShape(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrShapeList(
   _ a: [TensorShape?]
 ) {
@@ -1519,7 +1494,7 @@ public static func attrShapeList(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func attrTypeDefault<T: TensorFlowScalar>(
   _ a: Tensor<T>
 ) {
@@ -1567,7 +1542,7 @@ public static func attrTypeDefault<T: TensorFlowScalar>(
 ///     magnitude. Using squared magnitude can avoid extra calculations.
 ///
 /// - Output spectrogram: 3D representation of the audio frequencies as an image.
-@inlinable @inline(__always)
+@inlinable
 public static func audioSpectrogram(
   _ input: Tensor<Float>,
   windowSize: Int64,
@@ -1605,7 +1580,7 @@ public static func audioSpectrogram(
 ///   - max_outputs: Max number of batch elements to generate audio for.
 ///
 /// - Output summary: Scalar. Serialized `Summary` protocol buffer.
-@inlinable @inline(__always)
+@inlinable
 public static func audioSummary(
   tag: StringTensor,
   _ tensor: Tensor<Float>,
@@ -1642,7 +1617,7 @@ public static func audioSummary(
 /// - Attr max_outputs: Max number of batch elements to generate audio for.
 ///
 /// - Output summary: Scalar. Serialized `Summary` protocol buffer.
-@inlinable @inline(__always)
+@inlinable
 public static func audioSummaryV2(
   tag: StringTensor,
   _ tensor: Tensor<Float>,
@@ -1675,7 +1650,7 @@ public static func audioSummaryV2(
 ///         [batch, in_channels, in_height, in_width].
 ///
 /// - Output output: The average pooled output tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func avgPool<T: FloatingPoint & TensorFlowScalar>(
   value: Tensor<T>,
   ksize: [Int32],
@@ -1710,7 +1685,7 @@ public static func avgPool<T: FloatingPoint & TensorFlowScalar>(
 ///         [batch, in_channels, in_depth, in_height, in_width].
 ///
 /// - Output output: The average pooled output tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func avgPool3D<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   ksize: [Int32],
@@ -1747,7 +1722,7 @@ public static func avgPool3D<T: FloatingPoint & TensorFlowScalar>(
 ///         [batch, in_channels, in_depth, in_height, in_width].
 ///
 /// - Output output: The backprop for input.
-@inlinable @inline(__always)
+@inlinable
 public static func avgPool3DGrad<T: FloatingPoint & TensorFlowScalar>(
   origInputShape: Tensor<Int32>,
   grad: Tensor<T>,
@@ -1785,7 +1760,7 @@ public static func avgPool3DGrad<T: FloatingPoint & TensorFlowScalar>(
 ///         [batch, in_channels, in_height, in_width].
 ///
 /// - Output output: 4-D.  Gradients w.r.t. the input of `avg_pool`.
-@inlinable @inline(__always)
+@inlinable
 public static func avgPoolGrad<T: FloatingPoint & TensorFlowScalar>(
   origInputShape: Tensor<Int32>,
   grad: Tensor<T>,
@@ -1805,7 +1780,7 @@ public static func avgPoolGrad<T: FloatingPoint & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func b(
 ) -> Tensor<Float> {
   let op = TFE_Op("B")
@@ -1851,7 +1826,7 @@ public static func b(
 ///  same container and shared_name will batch their elements together. If left
 ///  empty, the op name will be used as the shared name.
 /// T: the types of tensors to be batched.
-@inlinable @inline(__always)
+@inlinable
 public static func batch<T: TensorArrayProtocol>(
   inTensors: T,
   numBatchThreads: Int64,
@@ -1879,7 +1854,7 @@ public static func batch<T: TensorArrayProtocol>(
   return op.execute(Int(inTensors._typeList.count), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchCholesky<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -1889,7 +1864,7 @@ public static func batchCholesky<T: FloatingPoint & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchCholeskyGrad<T: FloatingPoint & TensorFlowScalar>(
   l: Tensor<T>,
   grad: Tensor<T>
@@ -1905,7 +1880,7 @@ public static func batchCholeskyGrad<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Parameter batch_size: A scalar representing the number of elements to accumulate in a
 ///   batch.
-@inlinable @inline(__always)
+@inlinable
 public static func batchDataset(
   inputDataset: VariantHandle,
   batchSize: Tensor<Int64>,
@@ -1926,7 +1901,7 @@ public static func batchDataset(
 ///   - batch_size: A scalar representing the number of elements to accumulate in a batch.
 ///   - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
 ///     is smaller than desired.
-@inlinable @inline(__always)
+@inlinable
 public static func batchDatasetV2(
   inputDataset: VariantHandle,
   batchSize: Tensor<Int64>,
@@ -2009,7 +1984,7 @@ public static func batchDatasetV2(
 ///   - Tout: the types of the output tensors.
 ///
 /// - Output out_tensors: The output tensors.
-@inlinable @inline(__always)
+@inlinable
 public static func batchFunction<
     FIn: TensorGroup,
     FOut: TensorGroup,
@@ -2077,7 +2052,7 @@ public static func batchFunction<
 ///   - adj_y: If `True`, adjoint the slices of `y`. Defaults to `False`.
 ///
 /// - Output output: 3-D or higher with shape `[..., r_o, c_o]`
-@inlinable @inline(__always)
+@inlinable
 public static func batchMatMul<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>,
@@ -2128,7 +2103,7 @@ public static func batchMatMul<T: Numeric & TensorFlowScalar>(
 ///   - adj_y: If `True`, adjoint the slices of `y`. Defaults to `False`.
 ///
 /// - Output output: 3-D or higher with shape `[..., r_o, c_o]`
-@inlinable @inline(__always)
+@inlinable
 public static func batchMatMulV2<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>,
@@ -2144,7 +2119,7 @@ public static func batchMatMulV2<T: Numeric & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchMatrixBandPart<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   numLower: Tensor<Int64>,
@@ -2158,7 +2133,7 @@ public static func batchMatrixBandPart<T: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchMatrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -2168,7 +2143,7 @@ public static func batchMatrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchMatrixDiag<T: TensorFlowScalar>(
   diagonal: Tensor<T>
 ) -> Tensor<T> {
@@ -2178,7 +2153,7 @@ public static func batchMatrixDiag<T: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchMatrixDiagPart<T: TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -2188,7 +2163,7 @@ public static func batchMatrixDiagPart<T: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchMatrixInverse<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   adjoint: Bool = false
@@ -2200,7 +2175,7 @@ public static func batchMatrixInverse<T: FloatingPoint & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchMatrixSetDiag<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   diagonal: Tensor<T>
@@ -2212,7 +2187,7 @@ public static func batchMatrixSetDiag<T: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchMatrixSolve<T: FloatingPoint & TensorFlowScalar>(
   matrix: Tensor<T>,
   rhs: Tensor<T>,
@@ -2226,7 +2201,7 @@ public static func batchMatrixSolve<T: FloatingPoint & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchMatrixSolveLs<T: FloatingPoint & TensorFlowScalar>(
   matrix: Tensor<T>,
   rhs: Tensor<T>,
@@ -2242,7 +2217,7 @@ public static func batchMatrixSolveLs<T: FloatingPoint & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchMatrixTriangularSolve<T: FloatingPoint & TensorFlowScalar>(
   matrix: Tensor<T>,
   rhs: Tensor<T>,
@@ -2280,7 +2255,7 @@ public static func batchMatrixTriangularSolve<T: FloatingPoint & TensorFlowScala
 ///   - variance_epsilon: A small float number to avoid dividing by 0.
 ///   - scale_after_normalization: A bool indicating whether the resulted tensor
 ///     needs to be multiplied with gamma.
-@inlinable @inline(__always)
+@inlinable
 public static func batchNormWithGlobalNormalization<T: Numeric & TensorFlowScalar>(
   t: Tensor<T>,
   m: Tensor<T>,
@@ -2330,7 +2305,7 @@ public static func batchNormWithGlobalNormalization<T: Numeric & TensorFlowScala
 ///   - dv: 1D backprop tensor for variance.
 ///   - db: 1D backprop tensor for beta.
 ///   - dg: 1D backprop tensor for gamma.
-@inlinable @inline(__always)
+@inlinable
 public static func batchNormWithGlobalNormalizationGrad<T: Numeric & TensorFlowScalar>(
   t: Tensor<T>,
   m: Tensor<T>,
@@ -2352,7 +2327,7 @@ public static func batchNormWithGlobalNormalizationGrad<T: Numeric & TensorFlowS
   return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchSelfAdjointEig<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -2362,7 +2337,7 @@ public static func batchSelfAdjointEig<T: FloatingPoint & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchSelfAdjointEigV2<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   computeV: Bool = true
@@ -2374,7 +2349,7 @@ public static func batchSelfAdjointEigV2<T: FloatingPoint & TensorFlowScalar>(
   return op.execute(Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func batchSvd<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   computeUv: Bool = true,
@@ -2476,7 +2451,7 @@ public static func batchSvd<T: FloatingPoint & TensorFlowScalar>(
 ///        [[[5], [7]], [[13], [15]]],
 ///        [[[6], [8]], [[14], [16]]]]
 ///   ```
-@inlinable @inline(__always)
+@inlinable
 public static func batchToSpace<
     T: TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -2616,7 +2591,7 @@ public static func batchToSpace<
 ///          [[[9],  [10], [11],  [12]],
 ///           [[13], [14], [15],  [16]]]]
 ///     ```
-@inlinable @inline(__always)
+@inlinable
 public static func batchToSpaceND<
     T: TensorFlowScalar,
     TblockShape: BinaryInteger & TensorFlowScalar,
@@ -2642,7 +2617,7 @@ public static func batchToSpaceND<
 /// `bessel_i0e(x) = exp(-abs(x)) bessel_i0(x)`.
 ///
 /// This function is faster and numerically stabler than `bessel_i0(x)`.
-@inlinable @inline(__always)
+@inlinable
 public static func besselI0e<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -2658,7 +2633,7 @@ public static func besselI0e<T: FloatingPoint & TensorFlowScalar>(
 /// `bessel_i1e(x) = exp(-abs(x)) bessel_i1(x)`.
 ///
 /// This function is faster and numerically stabler than `bessel_i1(x)`.
-@inlinable @inline(__always)
+@inlinable
 public static func besselI1e<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -2683,7 +2658,7 @@ public static func besselI1e<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// is the incomplete beta function and \\(B(a, b)\\) is the *complete*
 /// beta function.
-@inlinable @inline(__always)
+@inlinable
 public static func betainc<T: FloatingPoint & TensorFlowScalar>(
   _ a: Tensor<T>,
   _ b: Tensor<T>,
@@ -2715,7 +2690,7 @@ public static func betainc<T: FloatingPoint & TensorFlowScalar>(
 ///       dimension.
 ///
 /// - Output output: Broadcasted sum of `value` and `bias`.
-@inlinable @inline(__always)
+@inlinable
 public static func biasAdd<T: Numeric & TensorFlowScalar>(
   value: Tensor<T>,
   bias: Tensor<T>,
@@ -2746,7 +2721,7 @@ public static func biasAdd<T: Numeric & TensorFlowScalar>(
 ///       dimension.
 ///
 /// - Output output: 1-D with size the feature dimension of `out_backprop`.
-@inlinable @inline(__always)
+@inlinable
 public static func biasAddGrad<T: Numeric & TensorFlowScalar>(
   outBackprop: Tensor<T>,
   dataFormat: DataFormat = .nhwc
@@ -2770,7 +2745,7 @@ public static func biasAddGrad<T: Numeric & TensorFlowScalar>(
 ///   - bias: 1-D with size the last dimension of `value`.
 ///
 /// - Output output: Broadcasted sum of `value` and `bias`.
-@inlinable @inline(__always)
+@inlinable
 public static func biasAddV1<T: Numeric & TensorFlowScalar>(
   value: Tensor<T>,
   bias: Tensor<T>
@@ -2782,7 +2757,7 @@ public static func biasAddV1<T: Numeric & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func binary<T: TensorFlowScalar>(
   _ a: Tensor<T>,
   _ b: Tensor<T>
@@ -2813,7 +2788,7 @@ public static func binary<T: TensorFlowScalar>(
 ///
 /// - Output bins: 1D `Tensor` with length equal to `size`. The counts or summed weights for
 ///   each value in the range [0, size).
-@inlinable @inline(__always)
+@inlinable
 public static func bincount<T: Numeric & TensorFlowScalar>(
   arr: Tensor<Int32>,
   size: Tensor<Int32>,
@@ -2878,7 +2853,7 @@ public static func bincount<T: Numeric & TensorFlowScalar>(
 ///
 /// *NOTE*: Bitcast is implemented as a low-level cast, so machines with different
 /// endian orderings will give different results.
-@inlinable @inline(__always)
+@inlinable
 public static func bitcast<
     T: Numeric & TensorFlowScalar,
     Type: Numeric & TensorFlowScalar
@@ -2896,7 +2871,7 @@ public static func bitcast<
 ///
 /// The result will have those bits set, that are set in both `x` and `y`. The
 /// computation is performed on the underlying representations of `x` and `y`.
-@inlinable @inline(__always)
+@inlinable
 public static func bitwiseAnd<T: BinaryInteger & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -2912,7 +2887,7 @@ public static func bitwiseAnd<T: BinaryInteger & TensorFlowScalar>(
 ///
 /// The result will have those bits set, that are set in `x`, `y` or both. The
 /// computation is performed on the underlying representations of `x` and `y`.
-@inlinable @inline(__always)
+@inlinable
 public static func bitwiseOr<T: BinaryInteger & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -2928,7 +2903,7 @@ public static func bitwiseOr<T: BinaryInteger & TensorFlowScalar>(
 ///
 /// The result will have those bits set, that are different in `x` and `y`. The
 /// computation is performed on the underlying representations of `x` and `y`.
-@inlinable @inline(__always)
+@inlinable
 public static func bitwiseXor<T: BinaryInteger & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -2985,7 +2960,7 @@ public static func bitwiseXor<T: BinaryInteger & TensorFlowScalar>(
 ///   - ci: The cell input over the whole time sequence.
 ///   - co: The cell after the tanh over the whole time sequence.
 ///   - h: The output h vector over the whole time sequence.
-@inlinable @inline(__always)
+@inlinable
 public static func blockLSTM<T: FloatingPoint & TensorFlowScalar>(
   seqLenMax: Tensor<Int64>,
   _ x: Tensor<T>,
@@ -3053,7 +3028,7 @@ public static func blockLSTM<T: FloatingPoint & TensorFlowScalar>(
 ///   - wcf_grad: The gradient for wcf to be back-propped.
 ///   - wco_grad: The gradient for wco to be back-propped.
 ///   - b_grad: The gradient for w to be back-propped.
-@inlinable @inline(__always)
+@inlinable
 public static func blockLSTMGrad<T: FloatingPoint & TensorFlowScalar>(
   seqLenMax: Tensor<Int64>,
   _ x: Tensor<T>,
@@ -3115,7 +3090,7 @@ public static func blockLSTMGrad<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output stats_summary: output Rank 4 Tensor (shape=[splits, feature_dimension, buckets, logits_dimension + hessian_dimension])
 ///   containing accumulated stats for each node, feature dimension and bucket.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesAggregateStats(
   nodeIds: Tensor<Int32>,
   gradients: Tensor<Float>,
@@ -3147,7 +3122,7 @@ public static func boostedTreesAggregateStats(
 /// - Attr num_features: inferred int; number of features.
 ///
 /// - Output buckets: int; List of Rank 1 Tensors each containing the bucketized values for a single feature.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesBucketize(
   floatValues: [Tensor<Float>],
   bucketBoundaries: [Tensor<Float>]
@@ -3190,7 +3165,7 @@ public static func boostedTreesBucketize(
 ///   - left_node_contribs: A Rank 2 tensors indicating the contribution of the left nodes when branching from parent nodes (given by the tensor element in the output node_ids_list) to the left direction by the given threshold for each feature. This value will be used to make the left node value by adding to the parent node value. Second dimension size is 1 for 1-dimensional logits, but would be larger for multi-class problems. See above for details like shapes and sizes.
 ///   - right_node_contribs: A Rank 2 tensors, with the same shape/conditions as left_node_contribs_list, but just that the value is for the right node.
 ///   - split_with_default_directions: A Rank 1 tensors indicating the which direction to go if data is missing. See above for details like shapes and sizes.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesCalculateBestFeatureSplit(
   nodeIdRange: Tensor<Int32>,
   statsSummary: Tensor<Float>,
@@ -3242,7 +3217,7 @@ public static func boostedTreesCalculateBestFeatureSplit(
 ///   - thresholds_list: An output list of Rank 1 tensors indicating the bucket id to compare with (as a threshold) for split in each node. See above for details like shapes and sizes.
 ///   - left_node_contribs_list: A list of Rank 2 tensors indicating the contribution of the left nodes when branching from parent nodes (given by the tensor element in the output node_ids_list) to the left direction by the given threshold for each feature. This value will be used to make the left node value by adding to the parent node value. Second dimension size is 1 for 1-dimensional logits, but would be larger for multi-class problems. See above for details like shapes and sizes.
 ///   - right_node_contribs_list: A list of Rank 2 tensors, with the same shape/conditions as left_node_contribs_list, but just that the value is for the right node.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesCalculateBestGainsPerFeature(
   nodeIdRange: Tensor<Int32>,
   statsSummaryList: [Tensor<Float>],
@@ -3274,7 +3249,7 @@ public static func boostedTreesCalculateBestGainsPerFeature(
 ///   - l2: l2 regularization factor on leaf weights, per instance based.
 ///
 /// - Output continue_centering: Bool, whether to continue bias centering.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesCenterBias(
   treeEnsembleHandle: ResourceHandle,
   meanGradients: Tensor<Float>,
@@ -3297,7 +3272,7 @@ public static func boostedTreesCenterBias(
 ///   - tree_ensemble_handle: Handle to the tree ensemble resource to be created.
 ///   - stamp_token: Token to use as the initial value of the resource stamp.
 ///   - tree_ensemble_serialized: Serialized proto of the tree ensemble.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesCreateEnsemble(
   treeEnsembleHandle: ResourceHandle,
   stampToken: Tensor<Int64>,
@@ -3318,7 +3293,7 @@ public static func boostedTreesCreateEnsemble(
 ///   - num_streams: int; The number of streams managed by the resource that shares the same epsilon.
 ///
 /// - Attr max_elements: int; The maximum number of data points that can be fed to the stream.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesCreateQuantileStreamResource(
   quantileStreamResourceHandle: ResourceHandle,
   epsilon: Tensor<Float>,
@@ -3341,7 +3316,7 @@ public static func boostedTreesCreateQuantileStreamResource(
 ///   - tree_ensemble_handle: Handle to the tree ensemble.
 ///   - stamp_token: Token to use as the new value of the resource stamp.
 ///   - tree_ensemble_serialized: Serialized proto of the ensemble.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesDeserializeEnsemble(
   treeEnsembleHandle: ResourceHandle,
   stampToken: Tensor<Int64>,
@@ -3355,7 +3330,7 @@ public static func boostedTreesDeserializeEnsemble(
 }
 
 /// Creates a handle to a BoostedTreesEnsembleResource
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesEnsembleResourceHandleOp(
   container: String,
   sharedName: String
@@ -3381,7 +3356,7 @@ public static func boostedTreesEnsembleResourceHandleOp(
 ///     examples_debug_outputs_serialized.
 ///
 /// - Output examples_debug_outputs_serialized: Output rank 1 Tensor containing a proto serialized as a string for each example.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesExampleDebugOutputs(
   treeEnsembleHandle: ResourceHandle,
   bucketizedFeatures: [Tensor<Int32>],
@@ -3406,7 +3381,7 @@ public static func boostedTreesExampleDebugOutputs(
 ///   - num_attempted_layers: The number of layers we attempted to build (but not necessarily succeeded).
 ///   - last_layer_nodes_range: Rank size 2 tensor that contains start and end ids of the nodes in the latest
 ///     layer.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesGetEnsembleStates(
   treeEnsembleHandle: ResourceHandle
 ) -> (stampToken: Tensor<Int64>, numTrees: Tensor<Int32>, numFinalizedTrees: Tensor<Int32>, numAttemptedLayers: Tensor<Int32>, lastLayerNodesRange: Tensor<Int32>) {
@@ -3430,7 +3405,7 @@ public static func boostedTreesGetEnsembleStates(
 ///
 /// - Output summaries: float; List of Rank 2 Tensors each containing the quantile summary
 ///   (value, weight, min_rank, max_rank) of a single feature.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesMakeQuantileSummaries(
   floatValues: [Tensor<Float>],
   exampleWeights: Tensor<Float>,
@@ -3460,7 +3435,7 @@ public static func boostedTreesMakeQuantileSummaries(
 ///   - num_features: int; inferred from the size of bucketized_features_list; the number of features.
 ///
 /// - Output stats_summary: output Rank 4 Tensor (shape=[#features, #splits, #buckets, 2]) containing accumulated stats put into the corresponding node and bucket. The first index of 4th dimension refers to gradients, and the second to hessians.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesMakeStatsSummary(
   nodeIds: Tensor<Int32>,
   gradients: Tensor<Float>,
@@ -3494,7 +3469,7 @@ public static func boostedTreesMakeStatsSummary(
 ///     shape.
 ///
 /// - Output logits: Output rank 2 Tensor containing logits for each example.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesPredict(
   treeEnsembleHandle: ResourceHandle,
   bucketizedFeatures: [Tensor<Int32>],
@@ -3517,7 +3492,7 @@ public static func boostedTreesPredict(
 /// - Parameters:
 ///   - quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
 ///   - summaries: string; List of Rank 2 Tensor each containing the summaries for a single feature.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesQuantileStreamResourceAddSummaries(
   quantileStreamResourceHandle: ResourceHandle,
   summaries: [Tensor<Float>]
@@ -3538,7 +3513,7 @@ public static func boostedTreesQuantileStreamResourceAddSummaries(
 ///   - bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a feature.
 ///
 /// - Attr num_streams: inferred int; number of features to get bucket boundaries for.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesQuantileStreamResourceDeserialize(
   quantileStreamResourceHandle: ResourceHandle,
   bucketBoundaries: [Tensor<Float>]
@@ -3564,7 +3539,7 @@ public static func boostedTreesQuantileStreamResourceDeserialize(
 ///   If False, the output will be the points in the histogram that we got which roughly
 ///   translates to 1/epsilon boundaries and without any duplicates.
 ///   Default to False.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesQuantileStreamResourceFlush(
   quantileStreamResourceHandle: ResourceHandle,
   numBuckets: Tensor<Int64>,
@@ -3587,7 +3562,7 @@ public static func boostedTreesQuantileStreamResourceFlush(
 /// - Attr num_features: inferred int; number of features to get bucket boundaries for.
 ///
 /// - Output bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a feature.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesQuantileStreamResourceGetBucketBoundaries(
   quantileStreamResourceHandle: ResourceHandle,
   numFeatures: Int64
@@ -3599,7 +3574,7 @@ public static func boostedTreesQuantileStreamResourceGetBucketBoundaries(
 }
 
 /// Creates a handle to a BoostedTreesQuantileStreamResource.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesQuantileStreamResourceHandleOp(
   container: String,
   sharedName: String
@@ -3617,7 +3592,7 @@ public static func boostedTreesQuantileStreamResourceHandleOp(
 /// - Outputs:
 ///   - stamp_token: Stamp token of the tree ensemble resource.
 ///   - tree_ensemble_serialized: Serialized proto of the ensemble.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesSerializeEnsemble(
   treeEnsembleHandle: ResourceHandle
 ) -> (stampToken: Tensor<Int64>, treeEnsembleSerialized: StringTensor) {
@@ -3650,7 +3625,7 @@ public static func boostedTreesSerializeEnsemble(
 ///     values stored) for each example.
 ///   - tree_ids: Rank 1 Tensor containing new tree ids for each example.
 ///   - node_ids: Rank 1 Tensor containing new node ids in the new tree_ids.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesTrainingPredict(
   treeEnsembleHandle: ResourceHandle,
   cachedTreeIds: Tensor<Int32>,
@@ -3694,7 +3669,7 @@ public static func boostedTreesTrainingPredict(
 /// - Attrs:
 ///   - pruning_mode: 0-No pruning, 1-Pre-pruning, 2-Post-pruning.
 ///   - num_features: Number of features that have best splits returned. INFERRED.
-@inlinable @inline(__always)
+@inlinable
 public static func boostedTreesUpdateEnsemble(
   treeEnsembleHandle: ResourceHandle,
   featureIds: Tensor<Int32>,
@@ -3726,7 +3701,7 @@ public static func boostedTreesUpdateEnsemble(
 ///
 /// Given `s0` and `s1`, tensors that represent shapes, compute `r0`, the
 /// broadcasted shape. `s0`, `s1` and `r0` are all integer vectors.
-@inlinable @inline(__always)
+@inlinable
 public static func broadcastArgs<T: BinaryInteger & TensorFlowScalar>(
   s0: Tensor<T>,
   s1: Tensor<T>
@@ -3741,7 +3716,7 @@ public static func broadcastArgs<T: BinaryInteger & TensorFlowScalar>(
 /// Return the reduction indices for computing gradients of s0 op s1 with broadcast.
 ///
 /// This is typically used by gradient computations for a broadcasting operation.
-@inlinable @inline(__always)
+@inlinable
 public static func broadcastGradientArgs<T: BinaryInteger & TensorFlowScalar>(
   s0: Tensor<T>,
   s1: Tensor<T>
@@ -3778,7 +3753,7 @@ public static func broadcastGradientArgs<T: BinaryInteger & TensorFlowScalar>(
 ///   - shape: An 1-D `int` Tensor. The shape of the desired output.
 ///
 /// - Output output: A Tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func broadcastTo<
     T: TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -3816,7 +3791,7 @@ public static func broadcastTo<
 ///   @compatibility(numpy)
 ///   Equivalent to np.digitize.
 ///   @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func bucketize<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   boundaries: [Double]
@@ -3857,7 +3832,7 @@ public static func bucketize<T: Numeric & TensorFlowScalar>(
 ///     Its values are: `[batch_size, max_decoded_length[j]]`.
 ///   - log_probability: A matrix, shaped: `(batch_size x top_paths)`.  The
 ///     sequence log-probabilities.
-@inlinable @inline(__always)
+@inlinable
 public static func cTCBeamSearchDecoder(
   inputs: Tensor<Float>,
   sequenceLength: Tensor<Int32>,
@@ -3901,7 +3876,7 @@ public static func cTCBeamSearchDecoder(
 ///     Values are: `[batch_size, max_decoded_length]`.
 ///   - log_probability: Matrix, size `(batch_size x 1)`, containing sequence
 ///     log-probabilities.
-@inlinable @inline(__always)
+@inlinable
 public static func cTCGreedyDecoder(
   inputs: Tensor<Float>,
   sequenceLength: Tensor<Int32>,
@@ -3941,7 +3916,7 @@ public static func cTCGreedyDecoder(
 ///   - loss: A vector (batch) containing log-probabilities.
 ///   - gradient: The gradient of `loss`.  3-D, shape:
 ///     `(max_time x batch_size x num_classes)`.
-@inlinable @inline(__always)
+@inlinable
 public static func cTCLoss(
   inputs: Tensor<Float>,
   labelsIndices: Tensor<Int64>,
@@ -3971,7 +3946,7 @@ public static func cTCLoss(
 ///
 /// - Parameter filename: A path on the filesystem where we should cache the dataset. Note: this
 ///   will be a directory.
-@inlinable @inline(__always)
+@inlinable
 public static func cacheDataset(
   inputDataset: VariantHandle,
   filename: StringTensor,
@@ -3987,7 +3962,7 @@ public static func cacheDataset(
 }
 
 /// Cast x of type SrcT to y of DstT.
-@inlinable @inline(__always)
+@inlinable
 public static func cast<
     Srct: TensorFlowScalar,
     Dstt: TensorFlowScalar
@@ -4004,7 +3979,7 @@ public static func cast<
 }
 
 /// Returns element-wise smallest integer not less than x.
-@inlinable @inline(__always)
+@inlinable
 public static func ceil<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -4020,7 +3995,7 @@ public static func ceil<T: FloatingPoint & TensorFlowScalar>(
 /// that are not a number (NaN) or infinity (Inf). Otherwise, passes `tensor` as-is.
 ///
 /// - Attr message: Prefix of the error message.
-@inlinable @inline(__always)
+@inlinable
 public static func checkNumerics<T: FloatingPoint & TensorFlowScalar>(
   _ tensor: Tensor<T>,
   message: String
@@ -4051,7 +4026,7 @@ public static func checkNumerics<T: FloatingPoint & TensorFlowScalar>(
 /// - Parameter input: Shape is `[..., M, M]`.
 ///
 /// - Output output: Shape is `[..., M, M]`.
-@inlinable @inline(__always)
+@inlinable
 public static func cholesky<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -4075,7 +4050,7 @@ public static func cholesky<T: FloatingPoint & TensorFlowScalar>(
 ///     this tensor.
 ///
 /// - Output output: Symmetrized version of df/dA . Shape is `[..., M, M]`
-@inlinable @inline(__always)
+@inlinable
 public static func choleskyGrad<T: FloatingPoint & TensorFlowScalar>(
   l: Tensor<T>,
   grad: Tensor<T>
@@ -4102,7 +4077,7 @@ public static func choleskyGrad<T: FloatingPoint & TensorFlowScalar>(
 ///     as `t`. The maximum value to clip by.
 ///
 /// - Output output: A clipped `Tensor` with the same shape as input 't'.
-@inlinable @inline(__always)
+@inlinable
 public static func clipByValue<T: Numeric & TensorFlowScalar>(
   t: Tensor<T>,
   clipValueMin: Tensor<T>,
@@ -4116,7 +4091,7 @@ public static func clipByValue<T: Numeric & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func closeSummaryWriter(
   writer: ResourceHandle
 ) {
@@ -4126,7 +4101,7 @@ public static func closeSummaryWriter(
 }
 
 /// Receives a tensor value broadcast from another device.
-@inlinable @inline(__always)
+@inlinable
 public static func collectiveBcastRecv<T: Numeric & TensorFlowScalar>(
   groupSize: Int64,
   groupKey: Int64,
@@ -4143,7 +4118,7 @@ public static func collectiveBcastRecv<T: Numeric & TensorFlowScalar>(
 }
 
 /// Broadcasts a tensor value to one or more other devices.
-@inlinable @inline(__always)
+@inlinable
 public static func collectiveBcastSend<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   groupSize: Int64,
@@ -4162,7 +4137,7 @@ public static func collectiveBcastSend<T: Numeric & TensorFlowScalar>(
 }
 
 /// Mutually accumulates multiple tensors of identical type and shape.
-@inlinable @inline(__always)
+@inlinable
 public static func collectiveGather<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   groupSize: Int64,
@@ -4196,7 +4171,7 @@ public static func collectiveGather<T: Numeric & TensorFlowScalar>(
 /// - Attr T: The type of elements to be exchanged.
 ///
 /// - Output output: The permuted input.
-@inlinable @inline(__always)
+@inlinable
 public static func collectivePermute<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   sourceTargetPairs: Tensor<Int32>
@@ -4209,7 +4184,7 @@ public static func collectivePermute<T: Numeric & TensorFlowScalar>(
 }
 
 /// Mutually reduces multiple tensors of identical type and shape.
-@inlinable @inline(__always)
+@inlinable
 public static func collectiveReduce<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   groupSize: Int64,
@@ -4284,7 +4259,7 @@ public static func collectiveReduce<T: Numeric & TensorFlowScalar>(
 ///     valid detections per batch item. Only the top num_detections[i] entries in
 ///     nms_boxes[i], nms_scores[i] and nms_class[i] are valid. The rest of the
 ///     entries are zero paddings.
-@inlinable @inline(__always)
+@inlinable
 public static func combinedNonMaxSuppression(
   boxes: Tensor<Float>,
   scores: Tensor<Float>,
@@ -4340,7 +4315,7 @@ public static func combinedNonMaxSuppression(
 /// - Attr T: The type of the input and threshold.
 ///
 /// - Output output: The bitpacked comparisons.
-@inlinable @inline(__always)
+@inlinable
 public static func compareAndBitpack<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   threshold: Tensor<T>
@@ -4368,7 +4343,7 @@ public static func compareAndBitpack<T: TensorFlowScalar>(
 /// # tensor `imag` is [4.75, 5.75]
 /// tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]]
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func complex<
     T: FloatingPoint & TensorFlowScalar,
     Tout: TensorFlowScalar
@@ -4390,7 +4365,7 @@ public static func complex<
 /// `float` or `double` that is the absolute value of each element in `x`. All
 /// elements in `x` must be complex numbers of the form \\(a + bj\\). The absolute
 /// value is computed as \\( \sqrt{a^2 + b^2}\\).
-@inlinable @inline(__always)
+@inlinable
 public static func complexAbs<
     T: TensorFlowScalar,
     Tout: FloatingPoint & TensorFlowScalar
@@ -4404,7 +4379,7 @@ public static func complexAbs<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func complexStruct<TC: TensorGroup>(
   nA: Int64,
   nB: Int64
@@ -4440,7 +4415,7 @@ public static func complexStruct<TC: TensorGroup>(
 ///     for the row with the corresponding index in indices.
 ///   - weights: A vector of the same length as indices and ids, in which each element
 ///     is -FLOAT_MAX.
-@inlinable @inline(__always)
+@inlinable
 public static func computeAccidentalHits(
   trueClasses: Tensor<Int64>,
   sampledCandidates: Tensor<Int64>,
@@ -4468,7 +4443,7 @@ public static func computeAccidentalHits(
 /// - Output output: A `Tensor` with the concatenation of values stacked along the
 ///   `concat_dim` dimension.  This tensor's shape matches that of `values` except
 ///   in `concat_dim` where it has the sum of the sizes.
-@inlinable @inline(__always)
+@inlinable
 public static func concat<T: TensorFlowScalar>(
   concatDim: Tensor<Int32>,
   _ values: [Tensor<T>]
@@ -4500,7 +4475,7 @@ public static func concat<T: TensorFlowScalar>(
 ///
 /// - Output offset: The `N` int32 vectors representing the starting offset
 ///   of input tensors within the concatenated output.
-@inlinable @inline(__always)
+@inlinable
 public static func concatOffset(
   concatDim: Tensor<Int32>,
   shape: [Tensor<Int32>]
@@ -4523,7 +4498,7 @@ public static func concatOffset(
 /// - Output output: A `Tensor` with the concatenation of values stacked along the
 ///   `concat_dim` dimension.  This tensor's shape matches that of `values` except
 ///   in `concat_dim` where it has the sum of the sizes.
-@inlinable @inline(__always)
+@inlinable
 public static func concatV2<
     T: TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -4541,7 +4516,7 @@ public static func concatV2<
 }
 
 /// Creates a dataset that concatenates `input_dataset` with `another_dataset`.
-@inlinable @inline(__always)
+@inlinable
 public static func concatenateDataset(
   inputDataset: VariantHandle,
   anotherDataset: VariantHandle,
@@ -4566,7 +4541,7 @@ public static func concatenateDataset(
 ///
 /// - Output topology: A serialized tensorflow.tpu.TopologyProto that describes the TPU
 ///   topology.
-@inlinable @inline(__always)
+@inlinable
 public static func configureDistributedTPU(
   embeddingConfig: String,
   tpuEmbeddingConfig: String,
@@ -4594,7 +4569,7 @@ public static func configureDistributedTPU(
 /// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
 /// tf.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func conj<T: TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -4609,7 +4584,7 @@ public static func conj<T: TensorFlowScalar>(
 /// The output `y` has the same rank as `x`. The shapes of `x` and `y` satisfy:
 ///   `y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]`
 ///   `y[i,j,k,...,s,t,u] == conj(x[perm[i], perm[j], perm[k],...,perm[s], perm[t], perm[u]])`
-@inlinable @inline(__always)
+@inlinable
 public static func conjugateTranspose<
     T: TensorFlowScalar,
     Tperm: BinaryInteger & TensorFlowScalar
@@ -4625,7 +4600,7 @@ public static func conjugateTranspose<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func constructionFails(
 ) {
   let op = TFE_Op("ConstructionFails")
@@ -4644,7 +4619,7 @@ public static func constructionFails(
 /// be enforced via the `colocate_with` mechanism.
 ///
 /// - Parameter mutex_lock: A tensor returned by `MutexLock`.
-@inlinable @inline(__always)
+@inlinable
 public static func consumeMutexLock(
   mutexLock: VariantHandle
 ) {
@@ -4656,7 +4631,7 @@ public static func consumeMutexLock(
 /// Does nothing. Serves as a control trigger for scheduling.
 ///
 /// Only useful as a placeholder for control edges.
-@inlinable @inline(__always)
+@inlinable
 public static func controlTrigger(
 ) {
   let op = TFE_Op("ControlTrigger")
@@ -4716,7 +4691,7 @@ public static func controlTrigger(
 ///
 /// - Output output: A 4-D tensor. The dimension order is determined by the value of
 ///   `data_format`, see below for details.
-@inlinable @inline(__always)
+@inlinable
 public static func conv2D<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   filter: Tensor<T>,
@@ -4773,7 +4748,7 @@ public static func conv2D<T: FloatingPoint & TensorFlowScalar>(
 /// - Output output: 4-D with shape
 ///   `[filter_height, filter_width, in_channels, out_channels]`.  Gradient w.r.t.
 ///   the `filter` input of the convolution.
-@inlinable @inline(__always)
+@inlinable
 public static func conv2DBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   filterSizes: Tensor<Int32>,
@@ -4831,7 +4806,7 @@ public static func conv2DBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output output: 4-D with shape `[batch, in_height, in_width, in_channels]`.  Gradient
 ///   w.r.t. the input of the convolution.
-@inlinable @inline(__always)
+@inlinable
 public static func conv2DBackpropInput<T: FloatingPoint & TensorFlowScalar>(
   inputSizes: Tensor<Int32>,
   filter: Tensor<T>,
@@ -4884,7 +4859,7 @@ public static func conv2DBackpropInput<T: FloatingPoint & TensorFlowScalar>(
 ///     filter element on that dimension. The dimension order is determined by the
 ///     value of `data_format`, see above for details. Dilations in the batch and
 ///     depth dimensions must be 1.
-@inlinable @inline(__always)
+@inlinable
 public static func conv3D<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   filter: Tensor<T>,
@@ -4917,7 +4892,7 @@ public static func conv3D<T: FloatingPoint & TensorFlowScalar>(
 ///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
 ///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
 ///   - padding: The type of padding algorithm to use.
-@inlinable @inline(__always)
+@inlinable
 public static func conv3DBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   filter: Tensor<T>,
@@ -4962,7 +4937,7 @@ public static func conv3DBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
 ///     filter element on that dimension. The dimension order is determined by the
 ///     value of `data_format`, see above for details. Dilations in the batch and
 ///     depth dimensions must be 1.
-@inlinable @inline(__always)
+@inlinable
 public static func conv3DBackpropFilterV2<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   filterSizes: Tensor<Int32>,
@@ -4997,7 +4972,7 @@ public static func conv3DBackpropFilterV2<T: FloatingPoint & TensorFlowScalar>(
 ///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
 ///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
 ///   - padding: The type of padding algorithm to use.
-@inlinable @inline(__always)
+@inlinable
 public static func conv3DBackpropInput<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   filter: Tensor<T>,
@@ -5042,7 +5017,7 @@ public static func conv3DBackpropInput<T: FloatingPoint & TensorFlowScalar>(
 ///     filter element on that dimension. The dimension order is determined by the
 ///     value of `data_format`, see above for details. Dilations in the batch and
 ///     depth dimensions must be 1.
-@inlinable @inline(__always)
+@inlinable
 public static func conv3DBackpropInputV2<
     T: FloatingPoint & TensorFlowScalar,
     Tshape: BinaryInteger & TensorFlowScalar
@@ -5090,7 +5065,7 @@ public static func conv3DBackpropInputV2<
 ///     "DebugIdentity;file:///tmp/tfdbg_1;0".
 ///
 /// - Output output: Output tensor, deep-copied from input.
-@inlinable @inline(__always)
+@inlinable
 public static func copy<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   tensorName: String,
@@ -5124,7 +5099,7 @@ public static func copy<T: TensorFlowScalar>(
 ///     "DebugIdentity;file:///tmp/tfdbg_1;0".
 ///
 /// - Output output: Output tensor, deep-copied from input.
-@inlinable @inline(__always)
+@inlinable
 public static func copyHost<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   tensorName: String,
@@ -5138,7 +5113,7 @@ public static func copyHost<T: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func copyOp<T: TensorFlowScalar>(
   _ a: Tensor<T>
 ) -> Tensor<T> {
@@ -5149,7 +5124,7 @@ public static func copyOp<T: TensorFlowScalar>(
 }
 
 /// Computes cos of x element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func cos<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -5160,7 +5135,7 @@ public static func cos<T: FloatingPoint & TensorFlowScalar>(
 }
 
 /// Computes hyperbolic cosine of x element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func cosh<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -5170,7 +5145,7 @@ public static func cosh<T: FloatingPoint & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func createSummaryDbWriter(
   writer: ResourceHandle,
   dbUri: StringTensor,
@@ -5187,7 +5162,7 @@ public static func createSummaryDbWriter(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func createSummaryFileWriter(
   writer: ResourceHandle,
   logdir: StringTensor,
@@ -5249,7 +5224,7 @@ public static func createSummaryFileWriter(
 ///   - extrapolation_value: Value used for extrapolation, when applicable.
 ///
 /// - Output crops: A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
-@inlinable @inline(__always)
+@inlinable
 public static func cropAndResize<T: Numeric & TensorFlowScalar>(
   image: Tensor<T>,
   boxes: Tensor<Float>,
@@ -5292,7 +5267,7 @@ public static func cropAndResize<T: Numeric & TensorFlowScalar>(
 ///   supported for now.
 ///
 /// - Output output: A 2-D tensor of shape `[num_boxes, 4]`.
-@inlinable @inline(__always)
+@inlinable
 public static func cropAndResizeGradBoxes<T: Numeric & TensorFlowScalar>(
   grads: Tensor<Float>,
   image: Tensor<T>,
@@ -5334,7 +5309,7 @@ public static func cropAndResizeGradBoxes<T: Numeric & TensorFlowScalar>(
 ///   supported for now.
 ///
 /// - Output output: A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
-@inlinable @inline(__always)
+@inlinable
 public static func cropAndResizeGradImage<T: FloatingPoint & TensorFlowScalar>(
   grads: Tensor<Float>,
   boxes: Tensor<Float>,
@@ -5363,7 +5338,7 @@ public static func cropAndResizeGradImage<T: FloatingPoint & TensorFlowScalar>(
 ///   - b: Another tensor, of same type and shape as `a`.
 ///
 /// - Output product: Pairwise cross product of the vectors in `a` and `b`.
-@inlinable @inline(__always)
+@inlinable
 public static func cross<T: Numeric & TensorFlowScalar>(
   _ a: Tensor<T>,
   _ b: Tensor<T>
@@ -5393,7 +5368,7 @@ public static func cross<T: Numeric & TensorFlowScalar>(
 /// - Attr T: The type of elements to be summed.
 ///
 /// - Output output: The sum of all the distributed inputs.
-@inlinable @inline(__always)
+@inlinable
 public static func crossReplicaSum<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   groupAssignment: Tensor<Int32>
@@ -5437,7 +5412,7 @@ public static func crossReplicaSum<T: Numeric & TensorFlowScalar>(
 ///   training.
 /// reserve_space: An opaque tensor that can be used in backprop calculation. It
 ///   is only produced if is_training is false.
-@inlinable @inline(__always)
+@inlinable
 public static func cudnnRNN<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   inputH: Tensor<T>,
@@ -5508,7 +5483,7 @@ public static func cudnnRNN<T: FloatingPoint & TensorFlowScalar>(
 ///     shape as input_c.
 /// params_backprop: The backprop to the params buffer in the forward pass. Has the
 ///     same shape as params.
-@inlinable @inline(__always)
+@inlinable
 public static func cudnnRNNBackprop<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   inputH: Tensor<T>,
@@ -5594,7 +5569,7 @@ public static func cudnnRNNBackprop<T: FloatingPoint & TensorFlowScalar>(
 ///     shape as input_c.
 /// params_backprop: The backprop to the params buffer in the forward pass. Has the
 ///     same shape as params.
-@inlinable @inline(__always)
+@inlinable
 public static func cudnnRNNBackpropV2<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   inputH: Tensor<T>,
@@ -5687,7 +5662,7 @@ public static func cudnnRNNBackpropV2<T: FloatingPoint & TensorFlowScalar>(
 ///     shape as input_c.
 /// params_backprop: The backprop to the params buffer in the forward pass. Has the
 ///     same shape as params.
-@inlinable @inline(__always)
+@inlinable
 public static func cudnnRNNBackpropV3<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   inputH: Tensor<T>,
@@ -5766,7 +5741,7 @@ public static func cudnnRNNBackpropV3<T: FloatingPoint & TensorFlowScalar>(
 /// dropout: dropout probability. When set to 0., dropout is disabled.
 /// seed: the 1st part of a seed to initialize dropout.
 /// seed2: the 2nd part of a seed to initialize dropout.
-@inlinable @inline(__always)
+@inlinable
 public static func cudnnRNNCanonicalToParams<T: FloatingPoint & TensorFlowScalar>(
   numLayers: Tensor<Int32>,
   numUnits: Tensor<Int32>,
@@ -5820,7 +5795,7 @@ public static func cudnnRNNCanonicalToParams<T: FloatingPoint & TensorFlowScalar
 ///   compatible across GPUs. Please use CudnnRNNParamsWeights and
 ///   CudnnRNNParamsBiases to save and restore them in a way that is compatible
 ///   across different runs.
-@inlinable @inline(__always)
+@inlinable
 public static func cudnnRNNParamsSize<S: BinaryInteger & TensorFlowScalar>(
   numLayers: Tensor<Int32>,
   numUnits: Tensor<Int32>,
@@ -5879,7 +5854,7 @@ public static func cudnnRNNParamsSize<S: BinaryInteger & TensorFlowScalar>(
 /// dropout: dropout probability. When set to 0., dropout is disabled.
 /// seed: the 1st part of a seed to initialize dropout.
 /// seed2: the 2nd part of a seed to initialize dropout.
-@inlinable @inline(__always)
+@inlinable
 public static func cudnnRNNParamsToCanonical<T: FloatingPoint & TensorFlowScalar>(
   numLayers: Tensor<Int32>,
   numUnits: Tensor<Int32>,
@@ -5944,7 +5919,7 @@ public static func cudnnRNNParamsToCanonical<T: FloatingPoint & TensorFlowScalar
 /// host_reserved: An opaque tensor that can be used in backprop calculation. It is
 ///   only produced if is_training is true. It is output on host memory rather than
 ///   device memory.
-@inlinable @inline(__always)
+@inlinable
 public static func cudnnRNNV2<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   inputH: Tensor<T>,
@@ -6013,7 +5988,7 @@ public static func cudnnRNNV2<T: FloatingPoint & TensorFlowScalar>(
 ///     major.
 /// reserve_space: An opaque tensor that can be used in backprop calculation. It
 ///   is only produced if is_training is true.
-@inlinable @inline(__always)
+@inlinable
 public static func cudnnRNNV3<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   inputH: Tensor<T>,
@@ -6088,7 +6063,7 @@ public static func cudnnRNNV3<T: FloatingPoint & TensorFlowScalar>(
 /// - Attrs:
 ///   - exclusive: If `True`, perform exclusive cumprod.
 ///   - reverse: A `bool` (default: False).
-@inlinable @inline(__always)
+@inlinable
 public static func cumprod<
     T: Numeric & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -6149,7 +6124,7 @@ public static func cumprod<
 /// - Attrs:
 ///   - exclusive: If `True`, perform exclusive cumsum.
 ///   - reverse: A `bool` (default: False).
-@inlinable @inline(__always)
+@inlinable
 public static func cumsum<
     T: Numeric & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -6181,7 +6156,7 @@ public static func cumsum<
 ///   - dst_format: destination data format.
 ///
 /// - Output y: A Tensor with each element as a dimension index in destination data format.
-@inlinable @inline(__always)
+@inlinable
 public static func dataFormatDimMap<T: BinaryInteger & TensorFlowScalar>(
   _ x: Tensor<T>,
   srcFormat: String = "NHWC",
@@ -6206,7 +6181,7 @@ public static func dataFormatDimMap<T: BinaryInteger & TensorFlowScalar>(
 ///   - dst_format: destination data format.
 ///
 /// - Output y: Vector of size 4 or Tensor of shape (4, 2) in destination data format.
-@inlinable @inline(__always)
+@inlinable
 public static func dataFormatVecPermute<T: BinaryInteger & TensorFlowScalar>(
   _ x: Tensor<T>,
   srcFormat: String = "NHWC",
@@ -6227,7 +6202,7 @@ public static func dataFormatVecPermute<T: BinaryInteger & TensorFlowScalar>(
 /// - Parameter input_dataset: A variant tensor representing the dataset to return the graph representation for.
 ///
 /// - Output graph: The graph representation of the dataset (as serialized GraphDef).
-@inlinable @inline(__always)
+@inlinable
 public static func datasetToGraph(
   inputDataset: VariantHandle
 ) -> StringTensor {
@@ -6241,7 +6216,7 @@ public static func datasetToGraph(
 /// - Parameter dataset: A handle to a dataset that contains a single element.
 ///
 /// - Output components: The components of the single element of `input`.
-@inlinable @inline(__always)
+@inlinable
 public static func datasetToSingleElement<OutputTypes: TensorGroup>(
   dataset: VariantHandle,
   outputShapes: [TensorShape?]
@@ -6258,7 +6233,7 @@ public static func datasetToSingleElement<OutputTypes: TensorGroup>(
 /// This op is hidden from public in Python. It is used by TensorFlow Debugger to
 /// register gradient tensors for gradient debugging.
 /// This op operates on non-reference-type tensors.
-@inlinable @inline(__always)
+@inlinable
 public static func debugGradientIdentity<T: TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -6286,7 +6261,7 @@ public static func debugGradientIdentity<T: TensorFlowScalar>(
 ///     them, the output will be an empty Tensor.
 ///
 /// - Output output: Output tensor that equals the input tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func debugIdentity<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   deviceName: String,
@@ -6322,7 +6297,7 @@ public static func debugIdentity<T: TensorFlowScalar>(
 ///     them, the output will be an empty Tensor.
 ///
 /// - Output output: An integer output tensor that is the number of NaNs in the input.
-@inlinable @inline(__always)
+@inlinable
 public static func debugNanCount<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   deviceName: String,
@@ -6391,7 +6366,7 @@ public static func debugNanCount<T: TensorFlowScalar>(
 ///           proto for more details.
 ///     [13]: Number of dimensions of the tensor (ndims).
 ///     [14+]: Sizes of the dimensions.
-@inlinable @inline(__always)
+@inlinable
 public static func debugNumericSummary<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   deviceName: String,
@@ -6457,7 +6432,7 @@ public static func debugNumericSummary<T: TensorFlowScalar>(
 ///     option.)
 ///
 /// - Output image: 3-D with shape `[height, width, channels]`..
-@inlinable @inline(__always)
+@inlinable
 public static func decodeAndCropJpeg(
   contents: StringTensor,
   cropWindow: Tensor<Int32>,
@@ -6488,7 +6463,7 @@ public static func decodeAndCropJpeg(
 /// - Parameter input: Base64 strings to decode.
 ///
 /// - Output output: Decoded strings.
-@inlinable @inline(__always)
+@inlinable
 public static func decodeBase64(
   _ input: StringTensor
 ) -> StringTensor {
@@ -6511,7 +6486,7 @@ public static func decodeBase64(
 /// - Parameter contents: 0-D.  The BMP-encoded image.
 ///
 /// - Output image: 3-D with shape `[height, width, channels]`. RGB order
-@inlinable @inline(__always)
+@inlinable
 public static func decodeBmp(
   contents: StringTensor,
   channels: Int64 = 0
@@ -6543,7 +6518,7 @@ public static func decodeBmp(
 ///   - na_value: Additional string to recognize as NA/NaN.
 ///
 /// - Output output: Each tensor will have the same shape as records.
-@inlinable @inline(__always)
+@inlinable
 public static func decodeCSV<OutType: TensorArrayProtocol>(
   records: StringTensor,
   recordDefaults: OutType,
@@ -6579,7 +6554,7 @@ public static func decodeCSV<OutType: TensorArrayProtocol>(
 ///
 /// - Output output: A Tensor with the same shape as input `bytes`, uncompressed
 ///   from bytes.
-@inlinable @inline(__always)
+@inlinable
 public static func decodeCompressed(
   bytes: StringTensor,
   compressionType: String
@@ -6604,7 +6579,7 @@ public static func decodeCompressed(
 /// - Parameter contents: 0-D.  The GIF-encoded image.
 ///
 /// - Output image: 4-D with shape `[num_frames, height, width, 3]`. RGB channel order.
-@inlinable @inline(__always)
+@inlinable
 public static func decodeGif(
   contents: StringTensor
 ) -> Tensor<UInt8> {
@@ -6627,7 +6602,7 @@ public static func decodeGif(
 ///
 /// - Output binary_examples: Each string is a binary Example protocol buffer corresponding
 ///   to the respective element of `json_examples`.
-@inlinable @inline(__always)
+@inlinable
 public static func decodeJSONExample(
   jsonExamples: StringTensor
 ) -> StringTensor {
@@ -6676,7 +6651,7 @@ public static func decodeJSONExample(
 ///     option.)
 ///
 /// - Output image: 3-D with shape `[height, width, channels]`..
-@inlinable @inline(__always)
+@inlinable
 public static func decodeJpeg(
   contents: StringTensor,
   channels: Int64 = 0,
@@ -6697,7 +6672,7 @@ public static func decodeJpeg(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func decodePaddedRaw<OutType: Numeric & TensorFlowScalar>(
   inputBytes: StringTensor,
   fixedLength: Tensor<Int32>,
@@ -6734,7 +6709,7 @@ public static func decodePaddedRaw<OutType: Numeric & TensorFlowScalar>(
 /// - Attr channels: Number of color channels for the decoded image.
 ///
 /// - Output image: 3-D with shape `[height, width, channels]`.
-@inlinable @inline(__always)
+@inlinable
 public static func decodePng<Dtype: UnsignedInteger & TensorFlowScalar>(
   contents: StringTensor,
   channels: Int64 = 0
@@ -6817,7 +6792,7 @@ public static func decodePng<Dtype: UnsignedInteger & TensorFlowScalar>(
 ///   - values: List of tensors containing values for the corresponding field.
 ///     `values[i]` has datatype `output_types[i]`
 ///     and shape `[batch_shape, max(sizes[...,i])]`.
-@inlinable @inline(__always)
+@inlinable
 public static func decodeProtoV2<OutputTypes: TensorGroup>(
   bytes: StringTensor,
   messageType: String,
@@ -6848,7 +6823,7 @@ public static func decodeProtoV2<OutputTypes: TensorGroup>(
 /// - Output output: A Tensor with one more dimension than the input `bytes`.  The
 ///   added dimension will have size equal to the length of the elements
 ///   of `bytes` divided by the number of bytes to represent `out_type`.
-@inlinable @inline(__always)
+@inlinable
 public static func decodeRaw<OutType: TensorFlowScalar>(
   bytes: StringTensor,
   littleEndian: Bool = true
@@ -6886,7 +6861,7 @@ public static func decodeRaw<OutType: TensorFlowScalar>(
 /// - Outputs:
 ///   - audio: 2-D with shape `[length, channels]`.
 ///   - sample_rate: Scalar holding the sample rate found in the WAV header.
-@inlinable @inline(__always)
+@inlinable
 public static func decodeWav(
   contents: StringTensor,
   desiredChannels: Int64 = -1,
@@ -6905,7 +6880,7 @@ public static func decodeWav(
 ///
 /// - Output y:     y: A `Tensor` of type `T`. A copy of `x`. Guaranteed that `y`
 ///         is not an alias of `x`.
-@inlinable @inline(__always)
+@inlinable
 public static func deepCopy<T: TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -6920,7 +6895,7 @@ public static func deepCopy<T: TensorFlowScalar>(
 /// - Parameters:
 ///   - handle: A handle to the iterator to delete.
 ///   - deleter: A variant deleter.
-@inlinable @inline(__always)
+@inlinable
 public static func deleteIterator(
   handle: ResourceHandle,
   deleter: VariantHandle
@@ -6934,7 +6909,7 @@ public static func deleteIterator(
 /// Delete the tensor specified by its handle in the session.
 ///
 /// - Parameter handle: The handle for a tensor stored in the session state.
-@inlinable @inline(__always)
+@inlinable
 public static func deleteSessionTensor(
   handle: StringTensor
 ) {
@@ -6965,7 +6940,7 @@ public static func deleteSessionTensor(
 ///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
 ///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
 ///     is the max result set size across all `0...n-1` dimensions.
-@inlinable @inline(__always)
+@inlinable
 public static func denseToDenseSetOperation<T: BinaryInteger & TensorFlowScalar>(
   set1: Tensor<T>,
   set2: Tensor<T>,
@@ -7003,7 +6978,7 @@ public static func denseToDenseSetOperation<T: BinaryInteger & TensorFlowScalar>
 ///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
 ///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
 ///     is the max result set size across all `0...n-1` dimensions.
-@inlinable @inline(__always)
+@inlinable
 public static func denseToDenseSetOperation(
   set1: StringTensor,
   set2: StringTensor,
@@ -7054,7 +7029,7 @@ public static func denseToDenseSetOperation(
 ///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
 ///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
 ///     is the max result set size across all `0...n-1` dimensions.
-@inlinable @inline(__always)
+@inlinable
 public static func denseToSparseSetOperation<T: BinaryInteger & TensorFlowScalar>(
   set1: Tensor<T>,
   set2Indices: Tensor<Int64>,
@@ -7109,7 +7084,7 @@ public static func denseToSparseSetOperation<T: BinaryInteger & TensorFlowScalar
 ///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
 ///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
 ///     is the max result set size across all `0...n-1` dimensions.
-@inlinable @inline(__always)
+@inlinable
 public static func denseToSparseSetOperation(
   set1: StringTensor,
   set2Indices: Tensor<Int64>,
@@ -7222,7 +7197,7 @@ public static func denseToSparseSetOperation(
 /// ```
 ///
 /// - Attr block_size: The size of the spatial block, same as in Space2Depth.
-@inlinable @inline(__always)
+@inlinable
 public static func depthToSpace<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   blockSize: Int64,
@@ -7271,7 +7246,7 @@ public static func depthToSpace<T: TensorFlowScalar>(
 ///     element on that dimension. The dimension order is determined by the value of
 ///     `data_format`, see above for details. Dilations in the batch and depth
 ///     dimensions must be 1.
-@inlinable @inline(__always)
+@inlinable
 public static func depthwiseConv2dNative<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   filter: Tensor<T>,
@@ -7323,7 +7298,7 @@ public static func depthwiseConv2dNative<T: FloatingPoint & TensorFlowScalar>(
 /// - Output output: 4-D with shape
 ///   `[filter_height, filter_width, in_channels, out_channels]`.  Gradient w.r.t.
 ///   the `filter` input of the convolution.
-@inlinable @inline(__always)
+@inlinable
 public static func depthwiseConv2dNativeBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   filterSizes: Tensor<Int32>,
@@ -7377,7 +7352,7 @@ public static func depthwiseConv2dNativeBackpropFilter<T: FloatingPoint & Tensor
 ///   `data_format` is 'NHWC', output shape is `[batch, in_height,
 ///   in_width, in_channels]`.  Gradient w.r.t. the input of the
 ///   convolution.
-@inlinable @inline(__always)
+@inlinable
 public static func depthwiseConv2dNativeBackpropInput<T: FloatingPoint & TensorFlowScalar>(
   inputSizes: Tensor<Int32>,
   filter: Tensor<T>,
@@ -7478,7 +7453,7 @@ public static func depthwiseConv2dNativeBackpropInput<T: FloatingPoint & TensorF
 /// - Parameters:
 ///   - min_range: The minimum scalar value possibly produced for the input.
 ///   - max_range: The maximum scalar value possibly produced for the input.
-@inlinable @inline(__always)
+@inlinable
 public static func dequantize<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   minRange: Tensor<Float>,
@@ -7500,7 +7475,7 @@ public static func dequantize<T: TensorFlowScalar>(
 ///   - resource_handle: A handle to an iterator resource.
 ///   - serialized: A variant tensor storing the state of the iterator contained in the
 ///     resource.
-@inlinable @inline(__always)
+@inlinable
 public static func deserializeIterator(
   resourceHandle: ResourceHandle,
   serialized: VariantHandle
@@ -7559,7 +7534,7 @@ public static func deserializeIterator(
 ///   Must have 3 columns.
 ///
 /// - Attr dtype: The `dtype` of the serialized `SparseTensor` objects.
-@inlinable @inline(__always)
+@inlinable
 public static func deserializeManySparse<Dtype: TensorFlowScalar>(
   serializedSparse: StringTensor
 ) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
@@ -7617,7 +7592,7 @@ public static func deserializeManySparse<Dtype: TensorFlowScalar>(
 ///   must have 3 columns.
 ///
 /// - Attr dtype: The `dtype` of the serialized `SparseTensor` objects.
-@inlinable @inline(__always)
+@inlinable
 public static func deserializeSparse<
     Dtype: TensorFlowScalar,
     Tserialized: TensorFlowScalar
@@ -7679,7 +7654,7 @@ public static func deserializeSparse<
 ///   must have 3 columns.
 ///
 /// - Attr dtype: The `dtype` of the serialized `SparseTensor` objects.
-@inlinable @inline(__always)
+@inlinable
 public static func deserializeSparse<Dtype: TensorFlowScalar>(
   serializedSparse: StringTensor
 ) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
@@ -7699,7 +7674,7 @@ public static func deserializeSparse<Dtype: TensorFlowScalar>(
 ///
 /// - Attr ignore_lookup_error: whether to ignore the error when the resource
 ///   doesn't exist.
-@inlinable @inline(__always)
+@inlinable
 public static func destroyResourceOp(
   resource: ResourceHandle,
   ignoreLookupError: Bool = true
@@ -7710,7 +7685,7 @@ public static func destroyResourceOp(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func devicePlacementOp(
 ) -> StringTensor {
   let op = TFE_Op("DevicePlacementOp")
@@ -7739,7 +7714,7 @@ public static func devicePlacementOp(
 /// ```
 ///
 /// - Parameter diagonal: Rank k tensor where k is at most 1.
-@inlinable @inline(__always)
+@inlinable
 public static func diag<T: Numeric & TensorFlowScalar>(
   diagonal: Tensor<T>
 ) -> Tensor<T> {
@@ -7773,7 +7748,7 @@ public static func diag<T: Numeric & TensorFlowScalar>(
 /// - Parameter input: Rank k tensor where k is even and not zero.
 ///
 /// - Output diagonal: The extracted diagonal.
-@inlinable @inline(__always)
+@inlinable
 public static func diagPart<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -7786,7 +7761,7 @@ public static func diagPart<T: Numeric & TensorFlowScalar>(
 /// Computes Psi, the derivative of Lgamma (the log of the absolute value of
 ///
 /// `Gamma(x)`), element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func digamma<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -7834,7 +7809,7 @@ public static func digamma<T: FloatingPoint & TensorFlowScalar>(
 ///   - padding: The type of padding algorithm to use.
 ///
 /// - Output output: 4-D with shape `[batch, out_height, out_width, depth]`.
-@inlinable @inline(__always)
+@inlinable
 public static func dilation2D<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   filter: Tensor<T>,
@@ -7867,7 +7842,7 @@ public static func dilation2D<T: Numeric & TensorFlowScalar>(
 ///   - padding: The type of padding algorithm to use.
 ///
 /// - Output filter_backprop: 3-D with shape `[filter_height, filter_width, depth]`.
-@inlinable @inline(__always)
+@inlinable
 public static func dilation2DBackpropFilter<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   filter: Tensor<T>,
@@ -7902,7 +7877,7 @@ public static func dilation2DBackpropFilter<T: Numeric & TensorFlowScalar>(
 ///   - padding: The type of padding algorithm to use.
 ///
 /// - Output in_backprop: 4-D with shape `[batch, in_height, in_width, depth]`.
-@inlinable @inline(__always)
+@inlinable
 public static func dilation2DBackpropInput<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   filter: Tensor<T>,
@@ -7926,7 +7901,7 @@ public static func dilation2DBackpropInput<T: Numeric & TensorFlowScalar>(
 ///
 /// *NOTE*: `Div` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func div<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -7943,7 +7918,7 @@ public static func div<T: Numeric & TensorFlowScalar>(
 ///
 /// *NOTE*: `DivNoNan` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func divNoNan<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -7976,7 +7951,7 @@ public static func divNoNan<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output output: 4-D with the same shape as `images`. The batch of input images with
 ///   bounding boxes drawn on the images.
-@inlinable @inline(__always)
+@inlinable
 public static func drawBoundingBoxes<T: FloatingPoint & TensorFlowScalar>(
   images: Tensor<T>,
   boxes: Tensor<Float>
@@ -8010,7 +7985,7 @@ public static func drawBoundingBoxes<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output output: 4-D with the same shape as `images`. The batch of input images with
 ///   bounding boxes drawn on the images.
-@inlinable @inline(__always)
+@inlinable
 public static func drawBoundingBoxesV2<T: FloatingPoint & TensorFlowScalar>(
   images: Tensor<T>,
   boxes: Tensor<Float>,
@@ -8067,7 +8042,7 @@ public static func drawBoundingBoxesV2<T: FloatingPoint & TensorFlowScalar>(
 /// - Parameter partitions: Any shape.  Indices in the range `[0, num_partitions)`.
 ///
 /// - Attr num_partitions: The number of partitions to output.
-@inlinable @inline(__always)
+@inlinable
 public static func dynamicPartition<T: TensorFlowScalar>(
   data: Tensor<T>,
   partitions: Tensor<Int32>,
@@ -8145,7 +8120,7 @@ public static func dynamicPartition<T: TensorFlowScalar>(
 /// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
 /// <img style="width:100%" src="https://www.tensorflow.org/images/DynamicStitch.png" alt>
 /// </div>
-@inlinable @inline(__always)
+@inlinable
 public static func dynamicStitch<T: TensorFlowScalar>(
   indices: [Tensor<Int32>],
   data: [Tensor<T>]
@@ -8162,7 +8137,7 @@ public static func dynamicStitch<T: TensorFlowScalar>(
 ///
 /// semantics of the input, output, and attributes are the same as those for
 /// PyFunc.
-@inlinable @inline(__always)
+@inlinable
 public static func eagerPyFunc<
     Tin: TensorArrayProtocol,
     Tout: TensorGroup
@@ -8234,7 +8209,7 @@ public static func eagerPyFunc<
 ///       // output is a 2x2 matrix with edit distances normalized by truth lengths.
 ///       output = [[inf, 1.0],  // (0,0): no truth, (0,1): no hypothesis
 ///                 [0.5, 1.0]]  // (1,0): addition, (1,1): no hypothesis
-@inlinable @inline(__always)
+@inlinable
 public static func editDistance<T: TensorFlowScalar>(
   hypothesisIndices: Tensor<Int64>,
   hypothesisValues: Tensor<T>,
@@ -8260,7 +8235,7 @@ public static func editDistance<T: TensorFlowScalar>(
 ///
 /// See [Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)
 /// ](http://arxiv.org/abs/1511.07289)
-@inlinable @inline(__always)
+@inlinable
 public static func elu<T: FloatingPoint & TensorFlowScalar>(
   features: Tensor<T>
 ) -> Tensor<T> {
@@ -8278,7 +8253,7 @@ public static func elu<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output backprops: The gradients: `gradients * (outputs + 1)` if outputs < 0,
 ///   `gradients` otherwise.
-@inlinable @inline(__always)
+@inlinable
 public static func eluGrad<T: FloatingPoint & TensorFlowScalar>(
   gradients: Tensor<T>,
   outputs: Tensor<T>
@@ -8299,7 +8274,7 @@ public static func eluGrad<T: FloatingPoint & TensorFlowScalar>(
 /// - Attr init: If True, initialize the returned tensor with the default value of dtype.  Otherwise, the implementation is free not to initializethe tensor's content.
 ///
 /// - Output output: A `Tensor` of type `T`.
-@inlinable @inline(__always)
+@inlinable
 public static func empty<Dtype: TensorFlowScalar>(
   shape: Tensor<Int32>,
   init_: Bool = false
@@ -8319,7 +8294,7 @@ public static func empty<Dtype: TensorFlowScalar>(
 /// handle: an empty tensor list.
 /// element_dtype: the type of elements in the list.
 /// element_shape: a shape compatible with that of elements in the list.
-@inlinable @inline(__always)
+@inlinable
 public static func emptyTensorList<ShapeType: BinaryInteger & TensorFlowScalar>(
   elementShape: Tensor<ShapeType>,
   maxNumElements: Tensor<Int32>,
@@ -8347,7 +8322,7 @@ public static func emptyTensorList<ShapeType: BinaryInteger & TensorFlowScalar>(
 /// - Attr pad: Bool whether padding is applied at the ends.
 ///
 /// - Output output: Input strings encoded in base64.
-@inlinable @inline(__always)
+@inlinable
 public static func encodeBase64(
   _ input: StringTensor,
   pad: Bool = false
@@ -8392,7 +8367,7 @@ public static func encodeBase64(
 ///   - xmp_metadata: If not empty, embed this XMP metadata in the image header.
 ///
 /// - Output contents: 0-D. JPEG-encoded image.
-@inlinable @inline(__always)
+@inlinable
 public static func encodeJpeg(
   image: Tensor<UInt8>,
   format: Format,
@@ -8430,7 +8405,7 @@ public static func encodeJpeg(
 ///   - quality: An int quality to encode to.
 ///
 /// - Output contents: 0-D. JPEG-encoded image.
-@inlinable @inline(__always)
+@inlinable
 public static func encodeJpegVariableQuality(
   images: Tensor<UInt8>,
   quality: Tensor<Int32>
@@ -8460,7 +8435,7 @@ public static func encodeJpegVariableQuality(
 /// - Attr compression: Compression level.
 ///
 /// - Output contents: 0-D. PNG-encoded image.
-@inlinable @inline(__always)
+@inlinable
 public static func encodePng<T: UnsignedInteger & TensorFlowScalar>(
   image: Tensor<T>,
   compression: Int64 = -1
@@ -8522,7 +8497,7 @@ public static func encodePng<T: UnsignedInteger & TensorFlowScalar>(
 ///   - Tinput_types: The input types.
 ///
 /// - Output bytes: Tensor of serialized protos with shape `batch_shape`.
-@inlinable @inline(__always)
+@inlinable
 public static func encodeProto<TinputTypes: TensorArrayProtocol>(
   sizes: Tensor<Int32>,
   _ values: TinputTypes,
@@ -8555,7 +8530,7 @@ public static func encodeProto<TinputTypes: TensorArrayProtocol>(
 ///   - sample_rate: Scalar containing the sample frequency.
 ///
 /// - Output contents: 0-D. WAV-encoded file contents.
-@inlinable @inline(__always)
+@inlinable
 public static func encodeWav(
   audio: Tensor<Float>,
   sampleRate: Tensor<Int32>
@@ -8578,7 +8553,7 @@ public static func encodeWav(
 ///
 /// - Attr device_ordinal: The TPU device to use. Should be >= 0 and less than the number
 ///   of TPU cores in the task on which the node is placed.
-@inlinable @inline(__always)
+@inlinable
 public static func enqueueTPUEmbeddingIntegerBatch(
   batch: [Tensor<Int32>],
   modeOverride: StringTensor,
@@ -8627,7 +8602,7 @@ public static func enqueueTPUEmbeddingIntegerBatch(
 ///     the sum of the weights be 0 for 'mean' or the sum of the squared weights be
 ///     0 for 'sqrtn'. If combiners isn't passed, the default is to use 'sum' for
 ///     all tables.
-@inlinable @inline(__always)
+@inlinable
 public static func enqueueTPUEmbeddingSparseBatch<
     T1: BinaryInteger & TensorFlowScalar,
     T2: BinaryInteger & TensorFlowScalar,
@@ -8693,7 +8668,7 @@ public static func enqueueTPUEmbeddingSparseBatch<
 ///     corresponding input. The ith input is looked up using table_ids[i]. The size
 ///     of the table_ids list must be equal to that of sample_indices,
 ///     embedding_indices and aggregation_weights.
-@inlinable @inline(__always)
+@inlinable
 public static func enqueueTPUEmbeddingSparseTensorBatch<
     T1: BinaryInteger & TensorFlowScalar,
     T2: BinaryInteger & TensorFlowScalar,
@@ -8734,7 +8709,7 @@ public static func enqueueTPUEmbeddingSparseTensorBatch<
 /// - Attr shape: The expected (possibly partially specified) shape of the input tensor.
 ///
 /// - Output output: A tensor with the same shape and contents as the input tensor or value.
-@inlinable @inline(__always)
+@inlinable
 public static func ensureShape<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   shape: TensorShape?
@@ -8762,7 +8737,7 @@ public static func ensureShape<T: TensorFlowScalar>(
 ///   - parallel_iterations: The number of iterations allowed to run in parallel.
 ///
 /// - Output output: The same tensor as `data`.
-@inlinable @inline(__always)
+@inlinable
 public static func enter<T: TensorFlowScalar>(
   data: Tensor<T>,
   frameName: String,
@@ -8782,7 +8757,7 @@ public static func enter<T: TensorFlowScalar>(
 ///
 /// *NOTE*: `Equal` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func equal<T: TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -8798,7 +8773,7 @@ public static func equal<T: TensorFlowScalar>(
 ///
 /// *NOTE*: `Equal` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func equal(
   _ x: StringTensor,
   _ y: StringTensor
@@ -8811,7 +8786,7 @@ public static func equal(
 }
 
 /// Computes the Gauss error function of `x` element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func erf<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -8822,7 +8797,7 @@ public static func erf<T: FloatingPoint & TensorFlowScalar>(
 }
 
 /// Computes the complementary error function of `x` element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func erfc<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -8847,7 +8822,7 @@ public static func erfc<T: FloatingPoint & TensorFlowScalar>(
 /// - Attr keep_dims: If true, retain reduced dimensions with length 1.
 ///
 /// - Output output: The reduced tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func euclideanNorm<
     T: Numeric & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -8872,7 +8847,7 @@ public static func euclideanNorm<
 /// - Parameter data: The tensor to be made available to the parent frame.
 ///
 /// - Output output: The same tensor as `data`.
-@inlinable @inline(__always)
+@inlinable
 public static func exit<T: TensorFlowScalar>(
   data: Tensor<T>
 ) -> Tensor<T> {
@@ -8883,7 +8858,7 @@ public static func exit<T: TensorFlowScalar>(
 }
 
 /// Computes exponential of x element-wise.  \\(y = e^x\\).
-@inlinable @inline(__always)
+@inlinable
 public static func exp<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -8932,7 +8907,7 @@ public static func exp<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output output: Contains the same data as `input`, but its shape has an additional
 ///   dimension of size 1 added.
-@inlinable @inline(__always)
+@inlinable
 public static func expandDims<
     T: TensorFlowScalar,
     Tdim: BinaryInteger & TensorFlowScalar
@@ -8948,7 +8923,7 @@ public static func expandDims<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalAssertNextDataset(
   inputDataset: VariantHandle,
   transformations: StringTensor,
@@ -8977,7 +8952,7 @@ public static func experimentalAssertNextDataset(
 ///   - input_dataset: A variant tensor representing the input dataset.
 ///   - num_workers: A scalar representing the number of workers to distribute this dataset across.
 ///   - index: A scalar representing the index of the current worker out of num_workers.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalAutoShardDataset(
   inputDataset: VariantHandle,
   numWorkers: Tensor<Int64>,
@@ -8995,7 +8970,7 @@ public static func experimentalAutoShardDataset(
 }
 
 /// Records the bytes size of each element of `input_dataset` in a StatsAggregator.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalBytesProducedStatsDataset(
   inputDataset: VariantHandle,
   tag: StringTensor,
@@ -9010,7 +8985,7 @@ public static func experimentalBytesProducedStatsDataset(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalCSVDataset<OutputTypes: TensorArrayProtocol>(
   filenames: StringTensor,
   compressionType: StringTensor,
@@ -9038,7 +9013,7 @@ public static func experimentalCSVDataset<OutputTypes: TensorArrayProtocol>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalChooseFastestDataset(
   inputDatasets: [VariantHandle],
   numExperiments: Int64,
@@ -9062,7 +9037,7 @@ public static func experimentalChooseFastestDataset(
 ///
 /// - Output cardinality: The cardinality of `input_dataset`. Named constants are used to represent
 ///   infinite and unknown cardinality.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalDatasetCardinality(
   inputDataset: VariantHandle
 ) -> Tensor<Int64> {
@@ -9078,7 +9053,7 @@ public static func experimentalDatasetCardinality(
 ///   - filename: A scalar string tensor representing the filename to use.
 ///   - compression_type: A scalar string tensor containing either (i) the empty string (no
 ///     compression), (ii) "ZLIB", or (iii) "GZIP".
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalDatasetToTFRecord(
   inputDataset: VariantHandle,
   filename: StringTensor,
@@ -9100,7 +9075,7 @@ public static func experimentalDatasetToTFRecord(
 ///   - row_shape: A vector representing the dense shape of each row in the produced
 ///     SparseTensor. The shape may be partially specified, using `-1` to indicate
 ///     that a particular dimension should use the maximum size of all batch elements.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalDenseToSparseBatchDataset(
   inputDataset: VariantHandle,
   batchSize: Tensor<Int64>,
@@ -9124,7 +9099,7 @@ public static func experimentalDenseToSparseBatchDataset(
 ///     `N` data inputs should produce the next output element.
 ///   - data_input_datasets: `N` datasets with the same type that will be interleaved according to
 ///     the values of `selector_input_dataset`.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalDirectedInterleaveDataset(
   selectorInputDataset: VariantHandle,
   dataInputDatasets: [VariantHandle],
@@ -9163,7 +9138,7 @@ public static func experimentalDirectedInterleaveDataset(
 ///   - reduce_func: A function mapping the current reducer state and an element of `input_dataset`,
 ///     concatenated with `reduce_func_other_arguments` to a new reducer state.
 ///   - finalize_func: A function mapping the final reducer state to an output element.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalGroupByReducerDataset<
     KeyfuncIn: TensorGroup,
     KeyfuncOut: TensorGroup,
@@ -9215,7 +9190,7 @@ public static func experimentalGroupByReducerDataset<
 ///
 /// - Attr key_func: A function mapping an element of `input_dataset`, concatenated
 ///   with `key_func_other_arguments` to a scalar value of type DT_INT64.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalGroupByWindowDataset<
     KeyfuncIn: TensorGroup,
     KeyfuncOut: TensorGroup,
@@ -9253,7 +9228,7 @@ public static func experimentalGroupByWindowDataset<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalIdentityIndexedDataset(
   size: Tensor<UInt64>
 ) -> VariantHandle {
@@ -9263,7 +9238,7 @@ public static func experimentalIdentityIndexedDataset(
 }
 
 /// Creates a dataset that contains the elements of `input_dataset` ignoring errors.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalIgnoreErrorsDataset(
   inputDataset: VariantHandle,
   outputTypes: [TensorDataType],
@@ -9276,7 +9251,7 @@ public static func experimentalIgnoreErrorsDataset(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalIndexedDatasetGet<OutputTypes: TensorGroup>(
   materialized: ResourceHandle,
   index: Tensor<UInt64>,
@@ -9290,7 +9265,7 @@ public static func experimentalIndexedDatasetGet<OutputTypes: TensorGroup>(
   return op.execute(Int(OutputTypes._typeList.count))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalIndexedDatasetMaterialize(
   dataset: VariantHandle,
   materialized: ResourceHandle
@@ -9302,7 +9277,7 @@ public static func experimentalIndexedDatasetMaterialize(
 }
 
 /// Returns the name of the device on which `resource` has been placed.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalIteratorGetDevice(
   resource: ResourceHandle
 ) -> StringTensor {
@@ -9311,7 +9286,7 @@ public static func experimentalIteratorGetDevice(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalLMDBDataset(
   filenames: StringTensor,
   outputTypes: [TensorDataType],
@@ -9325,7 +9300,7 @@ public static func experimentalLMDBDataset(
 }
 
 /// Records the latency of producing `input_dataset` elements in a StatsAggregator.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalLatencyStatsDataset(
   inputDataset: VariantHandle,
   tag: StringTensor,
@@ -9362,7 +9337,7 @@ public static func experimentalLatencyStatsDataset(
 ///     is smaller than desired.
 ///
 /// - Attr f: A function to apply to the outputs of `input_dataset`.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalMapAndBatchDataset<
     FIn: TensorGroup,
     FOut: TensorGroup,
@@ -9393,7 +9368,7 @@ public static func experimentalMapAndBatchDataset<
 }
 
 /// Creates a dataset that applies `f` to the outputs of `input_dataset`.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalMapDataset<
     FIn: TensorGroup,
     FOut: TensorGroup,
@@ -9419,7 +9394,7 @@ public static func experimentalMapDataset<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalMatchingFilesDataset(
   patterns: StringTensor
 ) -> VariantHandle {
@@ -9428,7 +9403,7 @@ public static func experimentalMatchingFilesDataset(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalMaterializedIndexDatasetHandle(
   container: String,
   sharedName: String,
@@ -9446,7 +9421,7 @@ public static func experimentalMaterializedIndexDatasetHandle(
 /// Creates a dataset that overrides the maximum intra-op parallelism.
 ///
 /// - Parameter max_intra_op_parallelism: Identifies the maximum intra-op parallelism to use.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalMaxIntraOpParallelismDataset(
   inputDataset: VariantHandle,
   maxIntraOpParallelism: Tensor<Int64>,
@@ -9461,7 +9436,7 @@ public static func experimentalMaxIntraOpParallelismDataset(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalNonSerializableDataset(
   inputDataset: VariantHandle,
   outputTypes: [TensorDataType],
@@ -9500,7 +9475,7 @@ public static func experimentalNonSerializableDataset(
 ///     is smaller than desired.
 ///
 /// - Attr f: A function to apply to the outputs of `input_dataset`.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalNumaMapAndBatchDataset<
     FIn: TensorGroup,
     FOut: TensorGroup,
@@ -9543,7 +9518,7 @@ public static func experimentalNumaMapAndBatchDataset<
 /// - Attr f: A function mapping elements of `input_dataset`, concatenated with
 ///   `other_arguments`, to a Dataset variant that contains elements matching
 ///   `output_types` and `output_shapes`.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalParallelInterleaveDataset<
     FIn: TensorGroup,
     FOut: TensorGroup,
@@ -9603,7 +9578,7 @@ public static func experimentalParallelInterleaveDataset<
 ///     given feature along this dimension.
 ///   - output_types: The type list for the return values.
 ///   - output_shapes: The list of shapes being produced.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalParseExampleDataset<Tdense: TensorArrayProtocol>(
   inputDataset: VariantHandle,
   numParallelCalls: Tensor<Int64>,
@@ -9634,7 +9609,7 @@ public static func experimentalParseExampleDataset<Tdense: TensorArrayProtocol>(
 /// Creates a dataset that uses a custom thread pool to compute `input_dataset`.
 ///
 /// - Parameter num_threads: Identifies the number of threads to use for the private threadpool.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalPrivateThreadPoolDataset(
   inputDataset: VariantHandle,
   numThreads: Tensor<Int64>,
@@ -9656,7 +9631,7 @@ public static func experimentalPrivateThreadPoolDataset(
 ///     seed2 is set to be non-zero, the random number generator is seeded
 ///     by the given seed.  Otherwise, a random seed is used.
 ///   - seed2: A second scalar seed to avoid seed collision.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalRandomDataset(
   seed: Tensor<Int64>,
   seed2: Tensor<Int64>,
@@ -9681,7 +9656,7 @@ public static func experimentalRandomDataset(
 ///   - num_workers: A scalar representing the number of workers to distribute this batch across. As
 ///     a result of this transformation the current batch size would end up being
 ///     divided  by this parameter.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalRebatchDataset(
   inputDataset: VariantHandle,
   numWorkers: Tensor<Int64>,
@@ -9697,7 +9672,7 @@ public static func experimentalRebatchDataset(
 }
 
 /// Creates a dataset successively reduces `f` over the elements of `input_dataset`.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalScanDataset<
     FIn: TensorGroup,
     FOut: TensorGroup,
@@ -9725,7 +9700,7 @@ public static func experimentalScanDataset<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalSetStatsAggregatorDataset(
   inputDataset: VariantHandle,
   statsAggregator: ResourceHandle,
@@ -9744,7 +9719,7 @@ public static func experimentalSetStatsAggregatorDataset(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalSleepDataset(
   inputDataset: VariantHandle,
   sleepMicroseconds: Tensor<Int64>,
@@ -9768,7 +9743,7 @@ public static func experimentalSleepDataset(
 ///     forward in one iteration. It must be positive.
 ///   - window_stride: A scalar representing the stride of the input elements of the sliding window.
 ///     It must be positive.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalSlidingWindowDataset(
   inputDataset: VariantHandle,
   windowSize: Tensor<Int64>,
@@ -9793,7 +9768,7 @@ public static func experimentalSlidingWindowDataset(
 ///   - driver_name: The database type. Currently, the only supported type is 'sqlite'.
 ///   - data_source_name: A connection string to connect to the database.
 ///   - query: A SQL query to execute.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalSqlDataset(
   driverName: StringTensor,
   dataSourceName: StringTensor,
@@ -9811,7 +9786,7 @@ public static func experimentalSqlDataset(
 }
 
 /// Creates a statistics manager resource.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalStatsAggregatorHandle(
   container: String,
   sharedName: String
@@ -9823,7 +9798,7 @@ public static func experimentalStatsAggregatorHandle(
 }
 
 /// Produces a summary of any statistics recorded by the given statistics manager.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalStatsAggregatorSummary(
   iterator: ResourceHandle
 ) -> StringTensor {
@@ -9844,7 +9819,7 @@ public static func experimentalStatsAggregatorSummary(
 ///   building a closure for `predicate`.
 ///
 /// - Attr predicate: A function returning a scalar boolean.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalTakeWhileDataset<
     PredicateIn: TensorGroup,
     PredicateOut: TensorGroup,
@@ -9869,7 +9844,7 @@ public static func experimentalTakeWhileDataset<
 /// Creates a dataset that uses a custom thread pool to compute `input_dataset`.
 ///
 /// - Parameter thread_pool: A resource produced by the ThreadPoolHandle op.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalThreadPoolDataset(
   inputDataset: VariantHandle,
   threadPool: ResourceHandle,
@@ -9896,7 +9871,7 @@ public static func experimentalThreadPoolDataset(
 ///
 /// - Output handle: A resource that can be consumed by one or more ExperimentalThreadPoolDataset
 ///   ops.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalThreadPoolHandle(
   numThreads: Int64,
   maxIntraOpParallelism: Int64 = 1,
@@ -9914,7 +9889,7 @@ public static func experimentalThreadPoolHandle(
 }
 
 /// A dataset that splits the elements of its input into multiple elements.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalUnbatchDataset(
   inputDataset: VariantHandle,
   outputTypes: [TensorDataType],
@@ -9928,7 +9903,7 @@ public static func experimentalUnbatchDataset(
 }
 
 /// Creates a dataset that contains the unique elements of `input_dataset`.
-@inlinable @inline(__always)
+@inlinable
 public static func experimentalUniqueDataset(
   inputDataset: VariantHandle,
   outputTypes: [TensorDataType],
@@ -9944,7 +9919,7 @@ public static func experimentalUniqueDataset(
 /// Computes exponential of x - 1 element-wise.
 ///
 /// I.e., \\(y = (\exp x) - 1\\).
-@inlinable @inline(__always)
+@inlinable
 public static func expm1<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -10000,7 +9975,7 @@ public static func expm1<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output glimpse: A tensor representing the glimpses `[batch_size,
 ///   glimpse_height, glimpse_width, channels]`.
-@inlinable @inline(__always)
+@inlinable
 public static func extractGlimpse(
   _ input: Tensor<Float>,
   size: Tensor<Int32>,
@@ -10049,7 +10024,7 @@ public static func extractGlimpse(
 ///   ksize_cols * depth]` containing image patches with size
 ///   `ksize_rows x ksize_cols x depth` vectorized in the "depth" dimension. Note
 ///   `out_rows` and `out_cols` are the dimensions of the output patches.
-@inlinable @inline(__always)
+@inlinable
 public static func extractImagePatches<T: Numeric & TensorFlowScalar>(
   images: Tensor<T>,
   ksizes: [Int32],
@@ -10077,7 +10052,7 @@ public static func extractImagePatches<T: Numeric & TensorFlowScalar>(
 ///   Defaults to int32.
 ///
 /// - Output image_shape: 1-D. The image shape with format [height, width, channels].
-@inlinable @inline(__always)
+@inlinable
 public static func extractJpegShape<OutputType: BinaryInteger & TensorFlowScalar>(
   contents: StringTensor
 ) -> Tensor<OutputType> {
@@ -10109,7 +10084,7 @@ public static func extractJpegShape<OutputType: BinaryInteger & TensorFlowScalar
 ///   with size `ksize_planes x ksize_rows x ksize_cols x depth` vectorized
 ///   in the "depth" dimension. Note `out_planes`, `out_rows` and `out_cols`
 ///   are the dimensions of the output patches.
-@inlinable @inline(__always)
+@inlinable
 public static func extractVolumePatches<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   ksizes: [Int32],
@@ -10138,7 +10113,7 @@ public static func extractVolumePatches<T: Numeric & TensorFlowScalar>(
 ///   @compatibility(numpy)
 ///   Equivalent to np.fft.fft
 ///   @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func fFT<Tcomplex: TensorFlowScalar>(
   _ input: Tensor<Tcomplex>
 ) -> Tensor<Tcomplex> {
@@ -10161,7 +10136,7 @@ public static func fFT<Tcomplex: TensorFlowScalar>(
 ///   @compatibility(numpy)
 ///   Equivalent to np.fft.fft2
 ///   @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func fFT2D<Tcomplex: TensorFlowScalar>(
   _ input: Tensor<Tcomplex>
 ) -> Tensor<Tcomplex> {
@@ -10184,7 +10159,7 @@ public static func fFT2D<Tcomplex: TensorFlowScalar>(
 ///   @compatibility(numpy)
 ///   Equivalent to np.fft.fftn with 3 dimensions.
 ///   @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func fFT3D<Tcomplex: TensorFlowScalar>(
   _ input: Tensor<Tcomplex>
 ) -> Tensor<Tcomplex> {
@@ -10210,7 +10185,7 @@ public static func fFT3D<Tcomplex: TensorFlowScalar>(
 ///     across multiple sessions.
 ///
 /// - Output handle: The handle to the queue.
-@inlinable @inline(__always)
+@inlinable
 public static func fIFOQueueV2(
   componentTypes: [TensorDataType],
   shapes: [TensorShape?],
@@ -10228,7 +10203,7 @@ public static func fIFOQueueV2(
 }
 
 /// Output a fact about factorials.
-@inlinable @inline(__always)
+@inlinable
 public static func fact(
 ) -> StringTensor {
   let op = TFE_Op("Fact")
@@ -10247,7 +10222,7 @@ public static func fact(
 ///         the output will not necessarily have this shape. Can be a partial shape.
 ///
 /// - Output output:     \"Fake\" output value. This should not be consumed by another op.
-@inlinable @inline(__always)
+@inlinable
 public static func fakeParam<Dtype: TensorFlowScalar>(
   shape: TensorShape?
 ) -> Tensor<Dtype> {
@@ -10275,7 +10250,7 @@ public static func fakeParam<Dtype: TensorFlowScalar>(
 /// `min_adj = scale * round(min / scale)` and `max_adj = max + min_adj - min`.
 ///
 /// Quantization is called fake since the output is still in floating point.
-@inlinable @inline(__always)
+@inlinable
 public static func fakeQuantWithMinMaxArgs(
   inputs: Tensor<Float>,
   min: Double = -6,
@@ -10300,7 +10275,7 @@ public static func fakeQuantWithMinMaxArgs(
 ///
 /// - Output backprops: Backpropagated gradients below the FakeQuantWithMinMaxArgs operation:
 ///   `gradients * (inputs >= min && inputs <= max)`.
-@inlinable @inline(__always)
+@inlinable
 public static func fakeQuantWithMinMaxArgsGradient(
   gradients: Tensor<Float>,
   inputs: Tensor<Float>,
@@ -10340,7 +10315,7 @@ public static func fakeQuantWithMinMaxArgsGradient(
 ///
 /// This operation has a gradient and thus allows for training `min` and `max`
 /// values.
-@inlinable @inline(__always)
+@inlinable
 public static func fakeQuantWithMinMaxVars(
   inputs: Tensor<Float>,
   min: Tensor<Float>,
@@ -10375,7 +10350,7 @@ public static func fakeQuantWithMinMaxVars(
 ///     `sum(gradients * (inputs < min))`.
 ///   - backprop_wrt_max: Backpropagated gradients w.r.t. max parameter:
 ///     `sum(gradients * (inputs > max))`.
-@inlinable @inline(__always)
+@inlinable
 public static func fakeQuantWithMinMaxVarsGradient(
   gradients: Tensor<Float>,
   inputs: Tensor<Float>,
@@ -10416,7 +10391,7 @@ public static func fakeQuantWithMinMaxVarsGradient(
 ///
 /// This operation has a gradient and thus allows for training `min` and `max`
 /// values.
-@inlinable @inline(__always)
+@inlinable
 public static func fakeQuantWithMinMaxVarsPerChannel(
   inputs: Tensor<Float>,
   min: Tensor<Float>,
@@ -10454,7 +10429,7 @@ public static func fakeQuantWithMinMaxVarsPerChannel(
 ///     `sum_per_d(gradients * (inputs < min))`.
 ///   - backprop_wrt_max: Backpropagated gradients w.r.t. max parameter, shape `[d]`:
 ///     `sum_per_d(gradients * (inputs > max))`.
-@inlinable @inline(__always)
+@inlinable
 public static func fakeQuantWithMinMaxVarsPerChannelGradient(
   gradients: Tensor<Float>,
   inputs: Tensor<Float>,
@@ -10502,7 +10477,7 @@ public static func fakeQuantWithMinMaxVarsPerChannelGradient(
 ///     @compatibility(numpy)
 ///     Equivalent to np.full
 ///     @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func fill<
     T: TensorFlowScalar,
     IndexType: BinaryInteger & TensorFlowScalar
@@ -10519,7 +10494,7 @@ public static func fill<
 }
 
 /// Creates a dataset containing elements of first component of `input_dataset` having true in the last component.
-@inlinable @inline(__always)
+@inlinable
 public static func filterByLastComponentDataset(
   inputDataset: VariantHandle,
   outputTypes: [TensorDataType],
@@ -10544,7 +10519,7 @@ public static func filterByLastComponentDataset(
 ///   building a closure for `predicate`.
 ///
 /// - Attr predicate: A function returning a scalar boolean.
-@inlinable @inline(__always)
+@inlinable
 public static func filterDataset<
     PredicateIn: TensorGroup,
     PredicateOut: TensorGroup,
@@ -10566,7 +10541,7 @@ public static func filterDataset<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func fiveFloatOutputs(
 ) -> (a: Tensor<Float>, b: Tensor<Float>, c: Tensor<Float>, d: Tensor<Float>, e: Tensor<Float>) {
   let op = TFE_Op("FiveFloatOutputs")
@@ -10585,7 +10560,7 @@ public static func fiveFloatOutputs(
 ///   - footer_bytes: A scalar representing the number of bytes to skip at the end
 ///     of a file.
 ///   - buffer_size: A scalar representing the number of bytes to buffer. Must be > 0.
-@inlinable @inline(__always)
+@inlinable
 public static func fixedLengthRecordDataset(
   filenames: StringTensor,
   headerBytes: Tensor<Int64>,
@@ -10602,7 +10577,7 @@ public static func fixedLengthRecordDataset(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func fixedLengthRecordDatasetV2(
   filenames: StringTensor,
   headerBytes: Tensor<Int64>,
@@ -10637,7 +10612,7 @@ public static func fixedLengthRecordDatasetV2(
 ///     are supported. Defaults to none.
 ///
 /// - Output reader_handle: The handle to reference the Reader.
-@inlinable @inline(__always)
+@inlinable
 public static func fixedLengthRecordReaderV2(
   headerBytes: Int64 = 0,
   recordBytes: Int64,
@@ -10723,7 +10698,7 @@ public static func fixedLengthRecordReaderV2(
 ///     candidate representing the number of times the candidate is expected
 ///     to occur in a batch of sampled candidates.  If unique=true, then this is a
 ///     probability.
-@inlinable @inline(__always)
+@inlinable
 public static func fixedUnigramCandidateSampler(
   trueClasses: Tensor<Int64>,
   numTrue: Int64,
@@ -10765,7 +10740,7 @@ public static func fixedUnigramCandidateSampler(
 /// - Attr f: A function mapping elements of `input_dataset`, concatenated with
 ///   `other_arguments`, to a Dataset variant that contains elements matching
 ///   `output_types` and `output_shapes`.
-@inlinable @inline(__always)
+@inlinable
 public static func flatMapDataset<
     FIn: TensorGroup,
     FOut: TensorGroup,
@@ -10787,7 +10762,7 @@ public static func flatMapDataset<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func floatInput(
   _ a: Tensor<Float>
 ) {
@@ -10796,7 +10771,7 @@ public static func floatInput(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func floatOutput(
 ) -> Tensor<Float> {
   let op = TFE_Op("FloatOutput")
@@ -10804,7 +10779,7 @@ public static func floatOutput(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func floatOutputStringOutput(
 ) -> (a: Tensor<Float>, b: StringTensor) {
   let op = TFE_Op("FloatOutputStringOutput")
@@ -10813,7 +10788,7 @@ public static func floatOutputStringOutput(
 }
 
 /// Returns element-wise largest integer not greater than x.
-@inlinable @inline(__always)
+@inlinable
 public static func floor<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -10827,7 +10802,7 @@ public static func floor<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// *NOTE*: `FloorDiv` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func floorDiv<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -10846,7 +10821,7 @@ public static func floorDiv<T: Numeric & TensorFlowScalar>(
 ///
 /// *NOTE*: `FloorMod` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func floorMod<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -10858,7 +10833,7 @@ public static func floorMod<T: Numeric & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func flushSummaryWriter(
   writer: ResourceHandle
 ) {
@@ -10867,7 +10842,7 @@ public static func flushSummaryWriter(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func foo1(
   _ a: Tensor<Float>,
   _ b: Tensor<Int32>,
@@ -10880,7 +10855,7 @@ public static func foo1(
   return op.execute(Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func foo2(
   _ a: Tensor<Float>,
   _ b: StringTensor,
@@ -10893,7 +10868,7 @@ public static func foo2(
   return op.execute(Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func foo3(
   _ a: Tensor<Float>,
   _ b: StringTensor,
@@ -10924,7 +10899,7 @@ public static func foo3(
 ///         list of tensors (T).
 ///
 /// - Output output: A list of output tensors whose types are T.
-@inlinable @inline(__always)
+@inlinable
 public static func for_<
     T: TensorArrayProtocol,
     BodyIn: TensorGroup,
@@ -10987,7 +10962,7 @@ public static func for_<
 ///   - output: output tensor after fractional avg pooling.
 ///   - row_pooling_sequence: row pooling sequence, needed to calculate gradient.
 ///   - col_pooling_sequence: column pooling sequence, needed to calculate gradient.
-@inlinable @inline(__always)
+@inlinable
 public static func fractionalAvgPool<T: Numeric & TensorFlowScalar>(
   value: Tensor<T>,
   poolingRatio: [Double],
@@ -11037,7 +11012,7 @@ public static func fractionalAvgPool<T: Numeric & TensorFlowScalar>(
 ///   The result would be [41/3, 26/3] for fractional avg pooling.
 ///
 /// - Output output: 4-D.  Gradients w.r.t. the input of `fractional_avg_pool`.
-@inlinable @inline(__always)
+@inlinable
 public static func fractionalAvgPoolGrad<T: Numeric & TensorFlowScalar>(
   origInputTensorShape: Tensor<Int64>,
   outBackprop: Tensor<T>,
@@ -11120,7 +11095,7 @@ public static func fractionalAvgPoolGrad<T: Numeric & TensorFlowScalar>(
 ///   - output: output tensor after fractional max pooling.
 ///   - row_pooling_sequence: row pooling sequence, needed to calculate gradient.
 ///   - col_pooling_sequence: column pooling sequence, needed to calculate gradient.
-@inlinable @inline(__always)
+@inlinable
 public static func fractionalMaxPool<T: Numeric & TensorFlowScalar>(
   value: Tensor<T>,
   poolingRatio: [Double],
@@ -11165,7 +11140,7 @@ public static func fractionalMaxPool<T: Numeric & TensorFlowScalar>(
 ///   The result would be [20, 16] for fractional max pooling.
 ///
 /// - Output output: 4-D.  Gradients w.r.t. the input of `fractional_max_pool`.
-@inlinable @inline(__always)
+@inlinable
 public static func fractionalMaxPoolGrad<T: Numeric & TensorFlowScalar>(
   origInput: Tensor<T>,
   origOutput: Tensor<T>,
@@ -11185,7 +11160,7 @@ public static func fractionalMaxPoolGrad<T: Numeric & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func funcAttr<FIn: TensorGroup,
     FOut: TensorGroup>(
   f: (FIn) -> FOut
@@ -11226,7 +11201,7 @@ public static func funcAttr<FIn: TensorGroup,
 ///     in the gradient computation.
 ///   - reserve_space_2: A 1D Tensor for the computed batch variance (inverted variance
 ///     in the cuDNN case), to be reused in the gradient computation.
-@inlinable @inline(__always)
+@inlinable
 public static func fusedBatchNorm<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>,
   scale: Tensor<T>,
@@ -11284,7 +11259,7 @@ public static func fusedBatchNorm<T: FloatingPoint & TensorFlowScalar>(
 ///   - reserve_space_3: Unused placeholder to match the mean input in FusedBatchNorm.
 ///   - reserve_space_4: Unused placeholder to match the variance input
 ///     in FusedBatchNorm.
-@inlinable @inline(__always)
+@inlinable
 public static func fusedBatchNormGrad<T: FloatingPoint & TensorFlowScalar>(
   yBackprop: Tensor<T>,
   _ x: Tensor<T>,
@@ -11343,7 +11318,7 @@ public static func fusedBatchNormGrad<T: FloatingPoint & TensorFlowScalar>(
 ///   - reserve_space_3: Unused placeholder to match the mean input in FusedBatchNorm.
 ///   - reserve_space_4: Unused placeholder to match the variance input
 ///     in FusedBatchNorm.
-@inlinable @inline(__always)
+@inlinable
 public static func fusedBatchNormGradV2<
     T: FloatingPoint & TensorFlowScalar,
     U: FloatingPoint & TensorFlowScalar
@@ -11403,7 +11378,7 @@ public static func fusedBatchNormGradV2<
 ///     in the gradient computation.
 ///   - reserve_space_2: A 1D Tensor for the computed batch variance (inverted variance
 ///     in the cuDNN case), to be reused in the gradient computation.
-@inlinable @inline(__always)
+@inlinable
 public static func fusedBatchNormV2<
     T: FloatingPoint & TensorFlowScalar,
     U: FloatingPoint & TensorFlowScalar
@@ -11456,7 +11431,7 @@ public static func fusedBatchNormV2<
 ///   - strides: 1-D of length 4.  The stride of the sliding window for each dimension
 ///     of `input`. Must be in the same order as the dimension specified with format.
 ///   - padding: The type of padding algorithm to use.
-@inlinable @inline(__always)
+@inlinable
 public static func fusedPadConv2D<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   paddings: Tensor<Int32>,
@@ -11504,7 +11479,7 @@ public static func fusedPadConv2D<T: FloatingPoint & TensorFlowScalar>(
 ///   - strides: 1-D of length 4.  The stride of the sliding window for each dimension
 ///     of `input`. Must be in the same order as the dimension specified with format.
 ///   - padding: The type of padding algorithm to use.
-@inlinable @inline(__always)
+@inlinable
 public static func fusedResizeAndPadConv2D<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   size: Tensor<Int32>,
@@ -11574,7 +11549,7 @@ public static func fusedResizeAndPadConv2D<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// h = (1-u) \circ c + u \circ h_prev
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func gRUBlockCell<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>,
   hPrev: Tensor<T>,
@@ -11676,7 +11651,7 @@ public static func gRUBlockCell<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// d_b_c = sum of d_c_bar along axis = 0
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func gRUBlockCellGrad<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>,
   hPrev: Tensor<T>,
@@ -11731,7 +11706,7 @@ public static func gRUBlockCellGrad<T: FloatingPoint & TensorFlowScalar>(
 /// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
 /// <img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
 /// </div>
-@inlinable @inline(__always)
+@inlinable
 public static func gather<
     Tparams: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -11862,7 +11837,7 @@ public static func gather<
 ///
 /// - Output output: Values from `params` gathered from indices given by `indices`, with
 ///   shape `indices.shape[:-1] + params.shape[indices.shape[-1]:]`.
-@inlinable @inline(__always)
+@inlinable
 public static func gatherNd<
     Tparams: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -11917,7 +11892,7 @@ public static func gatherNd<
 ///
 /// - Output output: Values from `params` gathered from indices given by `indices`, with
 ///   shape `params.shape[:axis] + indices.shape + params.shape[axis + 1:]`.
-@inlinable @inline(__always)
+@inlinable
 public static func gatherV2<
     Tparams: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar,
@@ -11942,7 +11917,7 @@ public static func gatherV2<
 /// If the values are the same as already configured values, this op is a no-op. If
 /// they are different, the current contents of the block cache is dropped, and a
 /// new block cache is created fresh.
-@inlinable @inline(__always)
+@inlinable
 public static func gcsConfigureBlockCache(
   maxCacheSize: Tensor<UInt64>,
   blockSize: Tensor<UInt64>,
@@ -11984,7 +11959,7 @@ public static func gcsConfigureBlockCache(
 /// Note be sure to feed the inputs to this op to ensure the credentials are not
 /// stored in a constant op within the graph that might accidentally be checkpointed
 /// or in other ways be persisted or exfiltrated.
-@inlinable @inline(__always)
+@inlinable
 public static func gcsConfigureCredentials(
   json: StringTensor
 ) {
@@ -12010,7 +11985,7 @@ public static func gcsConfigureCredentials(
 ///   - test_end_point: Do not use. For testing purposes only.
 ///
 /// - Output partitions: Serialized table partitions.
-@inlinable @inline(__always)
+@inlinable
 public static func generateBigQueryReaderPartitions(
   projectId: String,
   datasetId: String,
@@ -12077,7 +12052,7 @@ public static func generateBigQueryReaderPartitions(
 ///     is equal to the old ID that maps to the new ID i.  This element is -1 for any
 ///     new ID that is not found in the old vocabulary.
 ///   - num_present: Number of new vocab entries found in old vocab.
-@inlinable @inline(__always)
+@inlinable
 public static func generateVocabRemapping(
   newVocabFile: StringTensor,
   oldVocabFile: StringTensor,
@@ -12095,7 +12070,7 @@ public static func generateVocabRemapping(
 }
 
 /// Creates a dataset that invokes a function to generate elements.
-@inlinable @inline(__always)
+@inlinable
 public static func generatorDataset<
     InitfuncIn: TensorGroup,
     InitfuncOut: TensorGroup,
@@ -12137,7 +12112,7 @@ public static func generatorDataset<
 ///
 /// - Output handle: The handle for the tensor stored in the session state, represented
 ///   as a string.
-@inlinable @inline(__always)
+@inlinable
 public static func getSessionHandle<T: TensorFlowScalar>(
   value: Tensor<T>
 ) -> StringTensor {
@@ -12153,7 +12128,7 @@ public static func getSessionHandle<T: TensorFlowScalar>(
 ///
 /// - Output handle: The handle for the tensor stored in the session state, represented
 ///   as a ResourceHandle object.
-@inlinable @inline(__always)
+@inlinable
 public static func getSessionHandleV2<T: TensorFlowScalar>(
   value: Tensor<T>
 ) -> ResourceHandle {
@@ -12170,7 +12145,7 @@ public static func getSessionHandleV2<T: TensorFlowScalar>(
 /// - Attr dtype: The type of the output value.
 ///
 /// - Output value: The tensor for the given handle.
-@inlinable @inline(__always)
+@inlinable
 public static func getSessionTensor<Dtype: TensorFlowScalar>(
   handle: StringTensor
 ) -> Tensor<Dtype> {
@@ -12180,7 +12155,7 @@ public static func getSessionTensor<Dtype: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func graphDefVersion(
 ) -> Tensor<Int32> {
   let op = TFE_Op("GraphDefVersion")
@@ -12192,7 +12167,7 @@ public static func graphDefVersion(
 ///
 /// *NOTE*: `Greater` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func greater<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -12208,7 +12183,7 @@ public static func greater<T: Numeric & TensorFlowScalar>(
 ///
 /// *NOTE*: `GreaterEqual` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func greaterEqual<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -12228,7 +12203,7 @@ public static func greaterEqual<T: Numeric & TensorFlowScalar>(
 /// as input.
 ///
 /// Returns the input tensor without modification.
-@inlinable @inline(__always)
+@inlinable
 public static func guaranteeConst<T: TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -12249,7 +12224,7 @@ public static func guaranteeConst<T: TensorFlowScalar>(
 /// - Parameter images: 1-D or higher rank. HSV data to convert. Last dimension must be size 3.
 ///
 /// - Output output: `images` converted to RGB.
-@inlinable @inline(__always)
+@inlinable
 public static func hSVToRGB<T: FloatingPoint & TensorFlowScalar>(
   images: Tensor<T>
 ) -> Tensor<T> {
@@ -12276,7 +12251,7 @@ public static func hSVToRGB<T: FloatingPoint & TensorFlowScalar>(
 ///   - value_dtype: Type of the table values.
 ///
 /// - Output table_handle: Handle to a table.
-@inlinable @inline(__always)
+@inlinable
 public static func hashTableV2(
   container: String,
   sharedName: String,
@@ -12319,7 +12294,7 @@ public static func hashTableV2(
 ///   - nbins: Scalar `int32 Tensor`.  Number of histogram bins.
 ///
 /// - Output out: A 1-D `Tensor` holding histogram of values.
-@inlinable @inline(__always)
+@inlinable
 public static func histogramFixedWidth<
     T: Numeric & TensorFlowScalar,
     Dtype: BinaryInteger & TensorFlowScalar
@@ -12350,7 +12325,7 @@ public static func histogramFixedWidth<
 ///   - values: Any shape. Values to use to build the histogram.
 ///
 /// - Output summary: Scalar. Serialized `Summary` protocol buffer.
-@inlinable @inline(__always)
+@inlinable
 public static func histogramSummary<T: Numeric & TensorFlowScalar>(
   tag: StringTensor,
   _ values: Tensor<T>
@@ -12375,7 +12350,7 @@ public static func histogramSummary<T: Numeric & TensorFlowScalar>(
 ///   @compatibility(numpy)
 ///   Equivalent to np.fft.ifft
 ///   @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func iFFT<Tcomplex: TensorFlowScalar>(
   _ input: Tensor<Tcomplex>
 ) -> Tensor<Tcomplex> {
@@ -12398,7 +12373,7 @@ public static func iFFT<Tcomplex: TensorFlowScalar>(
 ///   @compatibility(numpy)
 ///   Equivalent to np.fft.ifft2
 ///   @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func iFFT2D<Tcomplex: TensorFlowScalar>(
   _ input: Tensor<Tcomplex>
 ) -> Tensor<Tcomplex> {
@@ -12421,7 +12396,7 @@ public static func iFFT2D<Tcomplex: TensorFlowScalar>(
 ///   @compatibility(numpy)
 ///   Equivalent to np.fft.ifftn with 3 dimensions.
 ///   @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func iFFT3D<Tcomplex: TensorFlowScalar>(
   _ input: Tensor<Tcomplex>
 ) -> Tensor<Tcomplex> {
@@ -12432,7 +12407,7 @@ public static func iFFT3D<Tcomplex: TensorFlowScalar>(
 }
 
 /// Return a tensor with the same shape and contents as the input tensor or value.
-@inlinable @inline(__always)
+@inlinable
 public static func identity<T: TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -12459,7 +12434,7 @@ public static func identity<T: TensorFlowScalar>(
 /// def ApplyG(op, dy, _):
 ///   return [None, g(dy)]  # Do not backprop to f(x).
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func identityN<T: TensorArrayProtocol>(
   _ input: T
 ) -> T {
@@ -12481,7 +12456,7 @@ public static func identityN<T: TensorArrayProtocol>(
 ///     with this shared_name. Otherwise, the node name is used instead.
 ///
 /// - Output reader_handle: The handle to reference the Reader.
-@inlinable @inline(__always)
+@inlinable
 public static func identityReaderV2(
   container: String,
   sharedName: String
@@ -12512,7 +12487,7 @@ public static func identityReaderV2(
 ///         types are the same as what then_branch returns.
 ///
 /// - Output output: A list of return values.
-@inlinable @inline(__always)
+@inlinable
 public static func if_<
     Tcond: TensorFlowScalar,
     Tin: TensorArrayProtocol,
@@ -12555,7 +12530,7 @@ public static func if_<
 ///
 /// Note, above `Q(a, x)` (`Igammac`) is the upper regularized complete
 /// Gamma function.
-@inlinable @inline(__always)
+@inlinable
 public static func igamma<T: FloatingPoint & TensorFlowScalar>(
   _ a: Tensor<T>,
   _ x: Tensor<T>
@@ -12568,7 +12543,7 @@ public static func igamma<T: FloatingPoint & TensorFlowScalar>(
 }
 
 /// Computes the gradient of `igamma(a, x)` wrt `a`.
-@inlinable @inline(__always)
+@inlinable
 public static func igammaGradA<T: FloatingPoint & TensorFlowScalar>(
   _ a: Tensor<T>,
   _ x: Tensor<T>
@@ -12594,7 +12569,7 @@ public static func igammaGradA<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// Note, above `P(a, x)` (`Igamma`) is the lower regularized complete
 /// Gamma function.
-@inlinable @inline(__always)
+@inlinable
 public static func igammac<T: FloatingPoint & TensorFlowScalar>(
   _ a: Tensor<T>,
   _ x: Tensor<T>
@@ -12619,7 +12594,7 @@ public static func igammac<T: FloatingPoint & TensorFlowScalar>(
 /// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
 /// tf.imag(input) ==> [4.75, 5.75]
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func imag<
     T: TensorFlowScalar,
     Tout: FloatingPoint & TensorFlowScalar
@@ -12642,7 +12617,7 @@ public static func imag<
 ///   - shape: Shape of the returned tensor.
 ///   - memory_region_name: Name of readonly memory region used by the tensor, see
 ///     NewReadOnlyMemoryRegionFromFile in tensorflow::Env.
-@inlinable @inline(__always)
+@inlinable
 public static func immutableConst<Dtype: TensorFlowScalar>(
   shape: TensorShape?,
   memoryRegionName: String
@@ -12654,7 +12629,7 @@ public static func immutableConst<Dtype: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func importEvent(
   writer: ResourceHandle,
   event: StringTensor
@@ -12665,7 +12640,7 @@ public static func importEvent(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func inPolymorphicTwice<T: TensorFlowScalar>(
   _ a: [Tensor<T>],
   _ b: [Tensor<T>]
@@ -12703,7 +12678,7 @@ public static func inPolymorphicTwice<T: TensorFlowScalar>(
 /// - Attr k: Number of top elements to look at for computing precision.
 ///
 /// - Output precision: Computed Precision at `k` as a `bool Tensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func inTopK<T: BinaryInteger & TensorFlowScalar>(
   predictions: Tensor<Float>,
   targets: Tensor<T>,
@@ -12740,7 +12715,7 @@ public static func inTopK<T: BinaryInteger & TensorFlowScalar>(
 ///   - k: Number of top elements to look at for computing precision.
 ///
 /// - Output precision: Computed precision at `k` as a `bool Tensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func inTopKV2<T: BinaryInteger & TensorFlowScalar>(
   predictions: Tensor<Float>,
   targets: Tensor<T>,
@@ -12761,7 +12736,7 @@ public static func inTopKV2<T: BinaryInteger & TensorFlowScalar>(
 ///   - shape: The shape of the tensor.
 ///
 /// - Output output: A tensor that will be provided using the infeed mechanism.
-@inlinable @inline(__always)
+@inlinable
 public static func infeedDequeue<Dtype: TensorFlowScalar>(
   shape: TensorShape?
 ) -> Tensor<Dtype> {
@@ -12778,7 +12753,7 @@ public static func infeedDequeue<Dtype: TensorFlowScalar>(
 ///   - shapes: The shapes of each tensor in `outputs`.
 ///
 /// - Output outputs: A list of tensors that will be provided using the infeed mechanism.
-@inlinable @inline(__always)
+@inlinable
 public static func infeedDequeueTuple<Dtypes: TensorGroup>(
   shapes: [TensorShape?]
 ) -> Dtypes {
@@ -12801,7 +12776,7 @@ public static func infeedDequeueTuple<Dtypes: TensorGroup>(
 ///   - device_ordinal: The TPU device to use. This should be -1 when the Op
 ///     is running on a TPU device, and >= 0 when the Op is running on the CPU
 ///     device.
-@inlinable @inline(__always)
+@inlinable
 public static func infeedEnqueue<Dtype: TensorFlowScalar>(
   _ input: Tensor<Dtype>,
   shape: TensorShape?,
@@ -12823,7 +12798,7 @@ public static func infeedEnqueue<Dtype: TensorFlowScalar>(
 ///
 /// - Attr device_ordinal: The TPU device to use. This should be -1 when the Op is running on a TPU device
 ///   and = 0 when the Op is running on the CPU device.
-@inlinable @inline(__always)
+@inlinable
 public static func infeedEnqueuePrelinearizedBuffer(
   _ input: VariantHandle,
   deviceOrdinal: Int64 = -1
@@ -12848,7 +12823,7 @@ public static func infeedEnqueuePrelinearizedBuffer(
 ///   - device_ordinal: The TPU device to use. This should be -1 when the Op
 ///     is running on a TPU device, and >= 0 when the Op is running on the CPU
 ///     device.
-@inlinable @inline(__always)
+@inlinable
 public static func infeedEnqueueTuple<Dtypes: TensorArrayProtocol>(
   inputs: Dtypes,
   shapes: [TensorShape?],
@@ -12887,7 +12862,7 @@ public static func infeedEnqueueTuple<Dtypes: TensorArrayProtocol>(
 ///     `value` values from.
 ///   - vocab_size: Number of elements of the file, use -1 if unknown.
 ///   - delimiter: Delimiter to separate fields in a line.
-@inlinable @inline(__always)
+@inlinable
 public static func initializeTableFromTextFileV2(
   tableHandle: ResourceHandle,
   filename: StringTensor,
@@ -12912,7 +12887,7 @@ public static func initializeTableFromTextFileV2(
 ///   - table_handle: Handle to a table which will be initialized.
 ///   - keys: Keys of type Tkey.
 ///   - values: Values of type Tval.
-@inlinable @inline(__always)
+@inlinable
 public static func initializeTableV2<
     Tkey: TensorFlowScalar,
     Tval: TensorFlowScalar
@@ -12940,7 +12915,7 @@ public static func initializeTableV2<
 ///   - v: A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
 ///
 /// - Output y: A `Tensor` of type T. An alias of `x`. The content of `y` is undefined if there are duplicates in `i`.
-@inlinable @inline(__always)
+@inlinable
 public static func inplaceAdd<T: TensorFlowScalar>(
   _ x: Tensor<T>,
   i: Tensor<Int32>,
@@ -12964,7 +12939,7 @@ public static func inplaceAdd<T: TensorFlowScalar>(
 ///   - v: A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
 ///
 /// - Output y: A `Tensor` of type T. An alias of `x`. The content of `y` is undefined if there are duplicates in `i`.
-@inlinable @inline(__always)
+@inlinable
 public static func inplaceSub<T: TensorFlowScalar>(
   _ x: Tensor<T>,
   i: Tensor<Int32>,
@@ -12988,7 +12963,7 @@ public static func inplaceSub<T: TensorFlowScalar>(
 ///   - v: A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
 ///
 /// - Output y: A `Tensor` of type T. An alias of `x`. The content of `y` is undefined if there are duplicates in `i`.
-@inlinable @inline(__always)
+@inlinable
 public static func inplaceUpdate<T: TensorFlowScalar>(
   _ x: Tensor<T>,
   i: Tensor<Int32>,
@@ -13002,7 +12977,7 @@ public static func inplaceUpdate<T: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func int64Output(
 ) -> Tensor<Int64> {
   let op = TFE_Op("Int64Output")
@@ -13010,7 +12985,7 @@ public static func int64Output(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func intAttr(
   foo: Int64 = 1
 ) -> Tensor<Int64> {
@@ -13019,7 +12994,7 @@ public static func intAttr(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func intInput(
   _ a: Tensor<Int32>
 ) {
@@ -13028,7 +13003,7 @@ public static func intInput(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func intInputFloatInput(
   _ a: Tensor<Int32>,
   _ b: Tensor<Float>
@@ -13039,7 +13014,7 @@ public static func intInputFloatInput(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func intInputIntOutput(
   _ a: Tensor<Int32>
 ) -> Tensor<Int32> {
@@ -13048,7 +13023,7 @@ public static func intInputIntOutput(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func intOutput(
 ) -> Tensor<Int32> {
   let op = TFE_Op("IntOutput")
@@ -13056,7 +13031,7 @@ public static func intOutput(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func intOutputFloatOutput(
 ) -> (a: Tensor<Int32>, b: Tensor<Float>) {
   let op = TFE_Op("IntOutputFloatOutput")
@@ -13075,7 +13050,7 @@ public static func intOutputFloatOutput(
 /// - Attr f: A function mapping elements of `input_dataset`, concatenated with
 ///   `other_arguments`, to a Dataset variant that contains elements matching
 ///   `output_types` and `output_shapes`.
-@inlinable @inline(__always)
+@inlinable
 public static func interleaveDataset<
     FIn: TensorGroup,
     FOut: TensorGroup,
@@ -13104,7 +13079,7 @@ public static func interleaveDataset<
 /// Computes the reciprocal of x element-wise.
 ///
 /// I.e., \\(y = 1 / x\\).
-@inlinable @inline(__always)
+@inlinable
 public static func inv<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -13118,7 +13093,7 @@ public static func inv<T: Numeric & TensorFlowScalar>(
 ///
 /// Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy`
 /// is the corresponding input gradient.
-@inlinable @inline(__always)
+@inlinable
 public static func invGrad<T: FloatingPoint & TensorFlowScalar>(
   _ y: Tensor<T>,
   dy: Tensor<T>
@@ -13134,7 +13109,7 @@ public static func invGrad<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// The result will have exactly those bits set, that are not set in `x`. The
 /// computation is performed on the underlying representation of x.
-@inlinable @inline(__always)
+@inlinable
 public static func invert<T: BinaryInteger & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -13165,7 +13140,7 @@ public static func invert<T: BinaryInteger & TensorFlowScalar>(
 /// - Parameter x: 1-D.
 ///
 /// - Output y: 1-D.
-@inlinable @inline(__always)
+@inlinable
 public static func invertPermutation<T: BinaryInteger & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -13180,7 +13155,7 @@ public static func invertPermutation<T: BinaryInteger & TensorFlowScalar>(
 /// - Parameter tree_ensemble_handle: Handle to the tree ensemble resouce.
 ///
 /// - Output is_initialized: output boolean on whether it is initialized or not.
-@inlinable @inline(__always)
+@inlinable
 public static func isBoostedTreesEnsembleInitialized(
   treeEnsembleHandle: ResourceHandle
 ) -> Tensor<Bool> {
@@ -13196,7 +13171,7 @@ public static func isBoostedTreesEnsembleInitialized(
 /// - Parameter quantile_stream_resource_handle: resource; The reference to quantile stream resource handle.
 ///
 /// - Output is_initialized: bool; True if the resource is initialized, False otherwise.
-@inlinable @inline(__always)
+@inlinable
 public static func isBoostedTreesQuantileStreamResourceInitialized(
   quantileStreamResourceHandle: ResourceHandle
 ) -> Tensor<Bool> {
@@ -13210,7 +13185,7 @@ public static func isBoostedTreesQuantileStreamResourceInitialized(
 /// @compatibility(numpy)
 /// Equivalent to np.isfinite
 /// @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func isFinite<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<Bool> {
@@ -13225,7 +13200,7 @@ public static func isFinite<T: FloatingPoint & TensorFlowScalar>(
 /// @compatibility(numpy)
 /// Equivalent to np.isinf
 /// @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func isInf<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<Bool> {
@@ -13240,7 +13215,7 @@ public static func isInf<T: FloatingPoint & TensorFlowScalar>(
 /// @compatibility(numpy)
 /// Equivalent to np.isnan
 /// @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func isNan<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<Bool> {
@@ -13254,7 +13229,7 @@ public static func isNan<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output handle: A handle to the iterator that can be passed to a "MakeIterator"
 ///   or "IteratorGetNext" op.
-@inlinable @inline(__always)
+@inlinable
 public static func iterator(
   sharedName: String,
   container: String,
@@ -13280,7 +13255,7 @@ public static func iterator(
 ///     element produced by the resulting iterator.
 ///
 /// - Output resource_handle: A handle to an iterator resource.
-@inlinable @inline(__always)
+@inlinable
 public static func iteratorFromStringHandle(
   stringHandle: StringTensor,
   outputTypes: [TensorDataType],
@@ -13293,7 +13268,7 @@ public static func iteratorFromStringHandle(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func iteratorFromStringHandleV2(
   stringHandle: StringTensor,
   outputTypes: [TensorDataType],
@@ -13307,7 +13282,7 @@ public static func iteratorFromStringHandleV2(
 }
 
 /// Gets the next output from the given iterator .
-@inlinable @inline(__always)
+@inlinable
 public static func iteratorGetNext<OutputTypes: TensorGroup>(
   iterator: ResourceHandle,
   outputShapes: [TensorShape?]
@@ -13320,7 +13295,7 @@ public static func iteratorGetNext<OutputTypes: TensorGroup>(
 }
 
 /// Gets the next output from the given iterator as an Optional variant.
-@inlinable @inline(__always)
+@inlinable
 public static func iteratorGetNextAsOptional(
   iterator: ResourceHandle,
   outputTypes: [TensorDataType],
@@ -13339,7 +13314,7 @@ public static func iteratorGetNextAsOptional(
 /// in situations where the iterator does not block the calling thread, or where
 /// the calling thread is not a member of the thread pool used to execute parallel
 /// operations (e.g. in eager mode).
-@inlinable @inline(__always)
+@inlinable
 public static func iteratorGetNextSync<OutputTypes: TensorGroup>(
   iterator: ResourceHandle,
   outputShapes: [TensorShape?]
@@ -13356,7 +13331,7 @@ public static func iteratorGetNextSync<OutputTypes: TensorGroup>(
 /// - Parameter resource_handle: A handle to an iterator resource.
 ///
 /// - Output string_handle: A string representation of the given handle.
-@inlinable @inline(__always)
+@inlinable
 public static func iteratorToStringHandle(
   resourceHandle: ResourceHandle
 ) -> StringTensor {
@@ -13365,7 +13340,7 @@ public static func iteratorToStringHandle(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func iteratorV2(
   sharedName: String,
   container: String,
@@ -13393,7 +13368,7 @@ public static func iteratorV2(
 ///   - seed: Scalar. Seed for initializing the random number generator.
 ///
 /// - Output index: Scalar with the index of the sampled point.
-@inlinable @inline(__always)
+@inlinable
 public static func kMC2ChainInitialization(
   distances: Tensor<Float>,
   seed: Tensor<Int64>
@@ -13404,7 +13379,7 @@ public static func kMC2ChainInitialization(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func kernelLabel(
 ) -> StringTensor {
   let op = TFE_Op("KernelLabel")
@@ -13412,7 +13387,7 @@ public static func kernelLabel(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func kernelLabelRequired(
   _ input: Tensor<Int32>
 ) -> StringTensor {
@@ -13438,7 +13413,7 @@ public static func kernelLabelRequired(
 ///     heuristic is used to sample O(log(num_to_sample)) additional points.
 ///
 /// - Output samples: Matrix of shape (num_to_sample, d). The sampled rows.
-@inlinable @inline(__always)
+@inlinable
 public static func kmeansPlusPlusInitialization(
   points: Tensor<Float>,
   numToSample: Tensor<Int64>,
@@ -13462,7 +13437,7 @@ public static func kmeansPlusPlusInitialization(
 /// - Parameter t: Typically 2-D, but may have any dimensions.
 ///
 /// - Output output: 0-D.
-@inlinable @inline(__always)
+@inlinable
 public static func l2Loss<T: FloatingPoint & TensorFlowScalar>(
   t: Tensor<T>
 ) -> Tensor<T> {
@@ -13493,7 +13468,7 @@ public static func l2Loss<T: FloatingPoint & TensorFlowScalar>(
 ///   - bias: An offset (usually positive to avoid dividing by 0).
 ///   - alpha: A scale factor, usually positive.
 ///   - beta: An exponent.
-@inlinable @inline(__always)
+@inlinable
 public static func lRN<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   depthRadius: Int64 = 5,
@@ -13525,7 +13500,7 @@ public static func lRN<T: FloatingPoint & TensorFlowScalar>(
 ///   - beta: An exponent.
 ///
 /// - Output output: The gradients for LRN.
-@inlinable @inline(__always)
+@inlinable
 public static func lRNGrad<T: FloatingPoint & TensorFlowScalar>(
   inputGrads: Tensor<T>,
   inputImage: Tensor<T>,
@@ -13597,7 +13572,7 @@ public static func lRNGrad<T: FloatingPoint & TensorFlowScalar>(
 ///   - ci: The cell input.
 ///   - co: The cell after the tanh.
 ///   - h: The output h vector.
-@inlinable @inline(__always)
+@inlinable
 public static func lSTMBlockCell<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>,
   csPrev: Tensor<T>,
@@ -13657,7 +13632,7 @@ public static func lSTMBlockCell<T: FloatingPoint & TensorFlowScalar>(
 ///   - wci_grad: The gradient for wci to be back-propped.
 ///   - wcf_grad: The gradient for wcf to be back-propped.
 ///   - wco_grad: The gradient for wco to be back-propped.
-@inlinable @inline(__always)
+@inlinable
 public static func lSTMBlockCellGrad<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>,
   csPrev: Tensor<T>,
@@ -13700,7 +13675,7 @@ public static func lSTMBlockCellGrad<T: FloatingPoint & TensorFlowScalar>(
 }
 
 /// Computes rectified linear: `max(features, features * alpha)`.
-@inlinable @inline(__always)
+@inlinable
 public static func leakyRelu<T: FloatingPoint & TensorFlowScalar>(
   features: Tensor<T>,
   alpha: Double = 0.2
@@ -13720,7 +13695,7 @@ public static func leakyRelu<T: FloatingPoint & TensorFlowScalar>(
 ///     OR the outputs of that operation (both work equivalently).
 ///
 /// - Output backprops: `gradients * (features > 0) + alpha * gradients * (featurs <= 0)`.
-@inlinable @inline(__always)
+@inlinable
 public static func leakyReluGrad<T: FloatingPoint & TensorFlowScalar>(
   gradients: Tensor<T>,
   features: Tensor<T>,
@@ -13771,7 +13746,7 @@ public static func leakyReluGrad<T: FloatingPoint & TensorFlowScalar>(
 ///     candidate representing the number of times the candidate is expected
 ///     to occur in a batch of sampled candidates.  If unique=true, then this is a
 ///     probability.
-@inlinable @inline(__always)
+@inlinable
 public static func learnedUnigramCandidateSampler(
   trueClasses: Tensor<Int64>,
   numTrue: Int64,
@@ -13796,7 +13771,7 @@ public static func learnedUnigramCandidateSampler(
 ///
 /// If `y` is negative, or greater than or equal to the width of `x` in bits the
 /// result is implementation defined.
-@inlinable @inline(__always)
+@inlinable
 public static func leftShift<T: BinaryInteger & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -13812,7 +13787,7 @@ public static func leftShift<T: BinaryInteger & TensorFlowScalar>(
 ///
 /// *NOTE*: `Less` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func less<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -13828,7 +13803,7 @@ public static func less<T: Numeric & TensorFlowScalar>(
 ///
 /// *NOTE*: `LessEqual` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func lessEqual<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -13841,7 +13816,7 @@ public static func lessEqual<T: Numeric & TensorFlowScalar>(
 }
 
 /// Computes the log of the absolute value of `Gamma(x)` element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func lgamma<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -13869,7 +13844,7 @@ public static func lgamma<T: FloatingPoint & TensorFlowScalar>(
 ///   - num: 0-D tensor. Number of values to generate.
 ///
 /// - Output output: 1-D. The generated values.
-@inlinable @inline(__always)
+@inlinable
 public static func linSpace<
     T: FloatingPoint & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -13918,7 +13893,7 @@ public static func linSpace<
 /// - Outputs:
 ///   - out: 1-D. Values present in `x` but not in `y`.
 ///   - idx: 1-D. Positions of `x` values preserved in `out`.
-@inlinable @inline(__always)
+@inlinable
 public static func listDiff<
     T: TensorFlowScalar,
     OutIdx: BinaryInteger & TensorFlowScalar
@@ -13934,7 +13909,7 @@ public static func listDiff<
   return op.execute(Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func listInput<T: TensorFlowScalar>(
   _ a: [Tensor<T>]
 ) {
@@ -13945,7 +13920,7 @@ public static func listInput<T: TensorFlowScalar>(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func listOutput<T: TensorGroup>(
 ) -> T {
   let op = TFE_Op("ListOutput")
@@ -14014,7 +13989,7 @@ public static func listOutput<T: TensorGroup>(
 ///
 /// - Output output_matrix: Output matrix containing existing values loaded from the
 ///   checkpoint, and with any missing values filled in from initializing_values.
-@inlinable @inline(__always)
+@inlinable
 public static func loadAndRemapMatrix(
   ckptPath: StringTensor,
   oldTensorName: StringTensor,
@@ -14049,7 +14024,7 @@ public static func loadAndRemapMatrix(
 ///   - parameters: Value of parameters used in the ADAM optimization algorithm.
 ///   - momenta: Value of momenta used in the ADAM optimization algorithm.
 ///   - velocities: Value of velocities used in the ADAM optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingADAMParameters(
   parameters: Tensor<Float>,
   momenta: Tensor<Float>,
@@ -14083,7 +14058,7 @@ public static func loadTPUEmbeddingADAMParameters(
 ///   - momenta: Value of momenta used in the ADAM optimization algorithm.
 ///   - velocities: Value of velocities used in the ADAM optimization algorithm.
 ///   - gradient_accumulators: Value of gradient_accumulators used in the ADAM optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingADAMParametersGradAccumDebug(
   parameters: Tensor<Float>,
   momenta: Tensor<Float>,
@@ -14118,7 +14093,7 @@ public static func loadTPUEmbeddingADAMParametersGradAccumDebug(
 ///   - parameters: Value of parameters used in the Adadelta optimization algorithm.
 ///   - accumulators: Value of accumulators used in the Adadelta optimization algorithm.
 ///   - updates: Value of updates used in the Adadelta optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingAdadeltaParameters(
   parameters: Tensor<Float>,
   accumulators: Tensor<Float>,
@@ -14152,7 +14127,7 @@ public static func loadTPUEmbeddingAdadeltaParameters(
 ///   - accumulators: Value of accumulators used in the Adadelta optimization algorithm.
 ///   - updates: Value of updates used in the Adadelta optimization algorithm.
 ///   - gradient_accumulators: Value of gradient_accumulators used in the Adadelta optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingAdadeltaParametersGradAccumDebug(
   parameters: Tensor<Float>,
   accumulators: Tensor<Float>,
@@ -14186,7 +14161,7 @@ public static func loadTPUEmbeddingAdadeltaParametersGradAccumDebug(
 /// - Parameters:
 ///   - parameters: Value of parameters used in the Adagrad optimization algorithm.
 ///   - accumulators: Value of accumulators used in the Adagrad optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingAdagradParameters(
   parameters: Tensor<Float>,
   accumulators: Tensor<Float>,
@@ -14217,7 +14192,7 @@ public static func loadTPUEmbeddingAdagradParameters(
 ///   - parameters: Value of parameters used in the Adagrad optimization algorithm.
 ///   - accumulators: Value of accumulators used in the Adagrad optimization algorithm.
 ///   - gradient_accumulators: Value of gradient_accumulators used in the Adagrad optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingAdagradParametersGradAccumDebug(
   parameters: Tensor<Float>,
   accumulators: Tensor<Float>,
@@ -14251,7 +14226,7 @@ public static func loadTPUEmbeddingAdagradParametersGradAccumDebug(
 ///   - ms: Value of ms used in the centered RMSProp optimization algorithm.
 ///   - mom: Value of mom used in the centered RMSProp optimization algorithm.
 ///   - mg: Value of mg used in the centered RMSProp optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingCenteredRMSPropParameters(
   parameters: Tensor<Float>,
   ms: Tensor<Float>,
@@ -14286,7 +14261,7 @@ public static func loadTPUEmbeddingCenteredRMSPropParameters(
 ///   - parameters: Value of parameters used in the FTRL optimization algorithm.
 ///   - accumulators: Value of accumulators used in the FTRL optimization algorithm.
 ///   - linears: Value of linears used in the FTRL optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingFTRLParameters(
   parameters: Tensor<Float>,
   accumulators: Tensor<Float>,
@@ -14320,7 +14295,7 @@ public static func loadTPUEmbeddingFTRLParameters(
 ///   - accumulators: Value of accumulators used in the FTRL optimization algorithm.
 ///   - linears: Value of linears used in the FTRL optimization algorithm.
 ///   - gradient_accumulators: Value of gradient_accumulators used in the FTRL optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingFTRLParametersGradAccumDebug(
   parameters: Tensor<Float>,
   accumulators: Tensor<Float>,
@@ -14356,7 +14331,7 @@ public static func loadTPUEmbeddingFTRLParametersGradAccumDebug(
 ///   - accumulators: Value of accumulators used in the MDL Adagrad Light optimization algorithm.
 ///   - weights: Value of weights used in the MDL Adagrad Light optimization algorithm.
 ///   - benefits: Value of benefits used in the MDL Adagrad Light optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingMDLAdagradLightParameters(
   parameters: Tensor<Float>,
   accumulators: Tensor<Float>,
@@ -14390,7 +14365,7 @@ public static func loadTPUEmbeddingMDLAdagradLightParameters(
 /// - Parameters:
 ///   - parameters: Value of parameters used in the Momentum optimization algorithm.
 ///   - momenta: Value of momenta used in the Momentum optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingMomentumParameters(
   parameters: Tensor<Float>,
   momenta: Tensor<Float>,
@@ -14421,7 +14396,7 @@ public static func loadTPUEmbeddingMomentumParameters(
 ///   - parameters: Value of parameters used in the Momentum optimization algorithm.
 ///   - momenta: Value of momenta used in the Momentum optimization algorithm.
 ///   - gradient_accumulators: Value of gradient_accumulators used in the Momentum optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingMomentumParametersGradAccumDebug(
   parameters: Tensor<Float>,
   momenta: Tensor<Float>,
@@ -14453,7 +14428,7 @@ public static func loadTPUEmbeddingMomentumParametersGradAccumDebug(
 /// - Parameters:
 ///   - parameters: Value of parameters used in the proximal Adagrad optimization algorithm.
 ///   - accumulators: Value of accumulators used in the proximal Adagrad optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingProximalAdagradParameters(
   parameters: Tensor<Float>,
   accumulators: Tensor<Float>,
@@ -14484,7 +14459,7 @@ public static func loadTPUEmbeddingProximalAdagradParameters(
 ///   - parameters: Value of parameters used in the proximal Adagrad optimization algorithm.
 ///   - accumulators: Value of accumulators used in the proximal Adagrad optimization algorithm.
 ///   - gradient_accumulators: Value of gradient_accumulators used in the proximal Adagrad optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingProximalAdagradParametersGradAccumDebug(
   parameters: Tensor<Float>,
   accumulators: Tensor<Float>,
@@ -14517,7 +14492,7 @@ public static func loadTPUEmbeddingProximalAdagradParametersGradAccumDebug(
 ///   - parameters: Value of parameters used in the RMSProp optimization algorithm.
 ///   - ms: Value of ms used in the RMSProp optimization algorithm.
 ///   - mom: Value of mom used in the RMSProp optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingRMSPropParameters(
   parameters: Tensor<Float>,
   ms: Tensor<Float>,
@@ -14551,7 +14526,7 @@ public static func loadTPUEmbeddingRMSPropParameters(
 ///   - ms: Value of ms used in the RMSProp optimization algorithm.
 ///   - mom: Value of mom used in the RMSProp optimization algorithm.
 ///   - gradient_accumulators: Value of gradient_accumulators used in the RMSProp optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingRMSPropParametersGradAccumDebug(
   parameters: Tensor<Float>,
   ms: Tensor<Float>,
@@ -14583,7 +14558,7 @@ public static func loadTPUEmbeddingRMSPropParametersGradAccumDebug(
 /// executed.
 ///
 /// - Parameter parameters: Value of parameters used in the stochastic gradient descent optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func loadTPUEmbeddingStochasticGradientDescentParameters(
   parameters: Tensor<Float>,
   tableId: Int64 = -1,
@@ -14603,7 +14578,7 @@ public static func loadTPUEmbeddingStochasticGradientDescentParameters(
 /// Computes natural logarithm of x element-wise.
 ///
 /// I.e., \\(y = \log_e x\\).
-@inlinable @inline(__always)
+@inlinable
 public static func log<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -14616,7 +14591,7 @@ public static func log<T: FloatingPoint & TensorFlowScalar>(
 /// Computes natural logarithm of (1 + x) element-wise.
 ///
 /// I.e., \\(y = \log_e (1 + x)\\).
-@inlinable @inline(__always)
+@inlinable
 public static func log1p<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -14644,7 +14619,7 @@ public static func log1p<T: FloatingPoint & TensorFlowScalar>(
 ///   - sign: The signs of the log determinants of the inputs. Shape is `[N]`.
 ///   - log_abs_determinant: The logs of the absolute values of the determinants
 ///     of the N input matrices.  Shape is `[N]`.
-@inlinable @inline(__always)
+@inlinable
 public static func logMatrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> (sign: Tensor<T>, logAbsDeterminant: Tensor<T>) {
@@ -14663,7 +14638,7 @@ public static func logMatrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
 /// - Parameter logits: 2-D with shape `[batch_size, num_classes]`.
 ///
 /// - Output logsoftmax: Same shape as `logits`.
-@inlinable @inline(__always)
+@inlinable
 public static func logSoftmax<T: FloatingPoint & TensorFlowScalar>(
   logits: Tensor<T>
 ) -> Tensor<T> {
@@ -14710,7 +14685,7 @@ public static func logSoftmax<T: FloatingPoint & TensorFlowScalar>(
 ///     candidate representing the number of times the candidate is expected
 ///     to occur in a batch of sampled candidates.  If unique=true, then this is a
 ///     probability.
-@inlinable @inline(__always)
+@inlinable
 public static func logUniformCandidateSampler(
   trueClasses: Tensor<Int64>,
   numTrue: Int64,
@@ -14735,7 +14710,7 @@ public static func logUniformCandidateSampler(
 ///
 /// *NOTE*: `LogicalAnd` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func logicalAnd(
   _ x: Tensor<Bool>,
   _ y: Tensor<Bool>
@@ -14747,7 +14722,7 @@ public static func logicalAnd(
 }
 
 /// Returns the truth value of NOT x element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func logicalNot(
   _ x: Tensor<Bool>
 ) -> Tensor<Bool> {
@@ -14760,7 +14735,7 @@ public static func logicalNot(
 ///
 /// *NOTE*: `LogicalOr` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func logicalOr(
   _ x: Tensor<Bool>,
   _ y: Tensor<Bool>
@@ -14778,7 +14753,7 @@ public static func logicalOr(
 /// - Outputs:
 ///   - keys: Vector of all keys present in the table.
 ///   - values: Tensor of all values in the table. Indexed in parallel with `keys`.
-@inlinable @inline(__always)
+@inlinable
 public static func lookupTableExportV2<
     Tkeys: TensorFlowScalar,
     Tvalues: TensorFlowScalar
@@ -14806,7 +14781,7 @@ public static func lookupTableExportV2<
 ///
 /// - Output values: Same shape as `keys`.  Values found in the table, or `default_values`
 ///   for missing keys.
-@inlinable @inline(__always)
+@inlinable
 public static func lookupTableFindV2<
     Tin: TensorFlowScalar,
     Tout: TensorFlowScalar
@@ -14833,7 +14808,7 @@ public static func lookupTableFindV2<
 ///   - table_handle: Handle to the table.
 ///   - keys: Any shape.  Keys to look up.
 ///   - values: Values to associate with keys.
-@inlinable @inline(__always)
+@inlinable
 public static func lookupTableImportV2<
     Tin: TensorFlowScalar,
     Tout: TensorFlowScalar
@@ -14860,7 +14835,7 @@ public static func lookupTableImportV2<
 ///   - table_handle: Handle to the table.
 ///   - keys: Any shape.  Keys to look up.
 ///   - values: Values to associate with keys.
-@inlinable @inline(__always)
+@inlinable
 public static func lookupTableInsertV2<
     Tin: TensorFlowScalar,
     Tout: TensorFlowScalar
@@ -14886,7 +14861,7 @@ public static func lookupTableInsertV2<
 /// - Parameters:
 ///   - table_handle: Handle to the table.
 ///   - keys: Any shape.  Keys of the elements to remove.
-@inlinable @inline(__always)
+@inlinable
 public static func lookupTableRemoveV2<Tin: TensorFlowScalar>(
   tableHandle: ResourceHandle,
   keys: Tensor<Tin>
@@ -14903,7 +14878,7 @@ public static func lookupTableRemoveV2<Tin: TensorFlowScalar>(
 /// - Parameter table_handle: Handle to the table.
 ///
 /// - Output size: Scalar that contains number of elements in the table.
-@inlinable @inline(__always)
+@inlinable
 public static func lookupTableSizeV2(
   tableHandle: ResourceHandle
 ) -> Tensor<Int64> {
@@ -14920,7 +14895,7 @@ public static func lookupTableSizeV2(
 /// - Parameter input: A boolean scalar, representing the branch predicate of the Switch op.
 ///
 /// - Output output: The same tensor as `input`.
-@inlinable @inline(__always)
+@inlinable
 public static func loopCond(
   _ input: Tensor<Bool>
 ) -> Tensor<Bool> {
@@ -14957,7 +14932,7 @@ public static func loopCond(
 /// - Output output: A `Tensor` with the same shape as `values`.  It contains the first scalar index
 ///   into the last dimension where values can be inserted without changing the
 ///   ordered property.
-@inlinable @inline(__always)
+@inlinable
 public static func lowerBound<
     T: TensorFlowScalar,
     OutType: BinaryInteger & TensorFlowScalar
@@ -15008,7 +14983,7 @@ public static func lowerBound<
 ///     the right hand side and the permutation `P` is returned as a list of indices
 ///     instead of a permutation matrix.
 ///     @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func lu<
     T: FloatingPoint & TensorFlowScalar,
     OutputIdxType: BinaryInteger & TensorFlowScalar
@@ -15026,7 +15001,7 @@ public static func lu<
 ///
 /// This operation may be executed multiple times. Each execution will reset the
 /// iterator in `iterator` to the first element of `dataset`.
-@inlinable @inline(__always)
+@inlinable
 public static func makeIterator(
   dataset: VariantHandle,
   iterator: ResourceHandle
@@ -15038,7 +15013,7 @@ public static func makeIterator(
 }
 
 /// Op removes all elements in the underlying container.
-@inlinable @inline(__always)
+@inlinable
 public static func mapClear(
   capacity: Int64 = 0,
   memoryLimit: Int64 = 0,
@@ -15056,7 +15031,7 @@ public static func mapClear(
 }
 
 /// Creates a dataset that applies `f` to the outputs of `input_dataset`.
-@inlinable @inline(__always)
+@inlinable
 public static func mapDataset<
     FIn: TensorGroup,
     FOut: TensorGroup,
@@ -15110,7 +15085,7 @@ public static func mapDataset<
 /// - Output output:     A list of output tensors whose types are `output_types` and whose dimensions
 ///       0 are the same as the dimensions 0 of the tensors in `arguments`, and whose
 ///       remaining dimensions correspond to those in `output_shapes`.
-@inlinable @inline(__always)
+@inlinable
 public static func mapDefun<
     Targuments: TensorArrayProtocol,
     Tcaptured: TensorArrayProtocol,
@@ -15137,7 +15112,7 @@ public static func mapDefun<
 }
 
 /// Op returns the number of incomplete elements in the underlying container.
-@inlinable @inline(__always)
+@inlinable
 public static func mapIncompleteSize(
   capacity: Int64 = 0,
   memoryLimit: Int64 = 0,
@@ -15158,7 +15133,7 @@ public static func mapIncompleteSize(
 ///
 /// underlying container does not contain this key
 /// this op will block until it does.
-@inlinable @inline(__always)
+@inlinable
 public static func mapPeek<Dtypes: TensorGroup>(
   key: Tensor<Int64>,
   indices: Tensor<Int32>,
@@ -15179,7 +15154,7 @@ public static func mapPeek<Dtypes: TensorGroup>(
 }
 
 /// Op returns the number of elements in the underlying container.
-@inlinable @inline(__always)
+@inlinable
 public static func mapSize(
   capacity: Int64 = 0,
   memoryLimit: Int64 = 0,
@@ -15209,7 +15184,7 @@ public static func mapSize(
 ///   - container: If non-empty, this queue is placed in the given container. Otherwise,
 ///     a default container is used.
 ///   - shared_name: It is necessary to match this name to the matching Unstage Op.
-@inlinable @inline(__always)
+@inlinable
 public static func mapStage<FakeDtypes: TensorArrayProtocol>(
   key: Tensor<Int64>,
   indices: Tensor<Int32>,
@@ -15237,7 +15212,7 @@ public static func mapStage<FakeDtypes: TensorArrayProtocol>(
 ///
 /// from the underlying container.   If the underlying container
 /// does not contain this key, the op will block until it does.
-@inlinable @inline(__always)
+@inlinable
 public static func mapUnstage<Dtypes: TensorGroup>(
   key: Tensor<Int64>,
   indices: Tensor<Int32>,
@@ -15261,7 +15236,7 @@ public static func mapUnstage<Dtypes: TensorGroup>(
 ///
 /// from the underlying container.   If the underlying container
 /// does not contain elements, the op will block until it does.
-@inlinable @inline(__always)
+@inlinable
 public static func mapUnstageNoKey<Dtypes: TensorGroup>(
   indices: Tensor<Int32>,
   capacity: Int64 = 0,
@@ -15292,7 +15267,7 @@ public static func mapUnstageNoKey<Dtypes: TensorGroup>(
 /// - Attrs:
 ///   - transpose_a: If true, "a" is transposed before multiplication.
 ///   - transpose_b: If true, "b" is transposed before multiplication.
-@inlinable @inline(__always)
+@inlinable
 public static func matMul<T: Numeric & TensorFlowScalar>(
   _ a: Tensor<T>,
   _ b: Tensor<T>,
@@ -15317,7 +15292,7 @@ public static func matMul<T: Numeric & TensorFlowScalar>(
 /// - Parameter pattern: Shell wildcard pattern(s). Scalar or vector of type string.
 ///
 /// - Output filenames: A vector of matching filenames.
-@inlinable @inline(__always)
+@inlinable
 public static func matchingFiles(
   pattern: StringTensor
 ) -> StringTensor {
@@ -15376,7 +15351,7 @@ public static func matchingFiles(
 ///     entire upper triangle.
 ///
 /// - Output band: Rank `k` tensor of the same shape as input. The extracted banded tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func matrixBandPart<
     T: TensorFlowScalar,
     Tindex: BinaryInteger & TensorFlowScalar
@@ -15403,7 +15378,7 @@ public static func matrixBandPart<
 /// - Parameter input: Shape is `[..., M, M]`.
 ///
 /// - Output output: Shape is `[...]`.
-@inlinable @inline(__always)
+@inlinable
 public static func matrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -15445,7 +15420,7 @@ public static func matrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
 /// - Parameter diagonal: Rank `k`, where `k >= 1`.
 ///
 /// - Output output: Rank `k+1`, with `output.shape = diagonal.shape + [diagonal.shape[-1]]`.
-@inlinable @inline(__always)
+@inlinable
 public static func matrixDiag<T: TensorFlowScalar>(
   diagonal: Tensor<T>
 ) -> Tensor<T> {
@@ -15490,7 +15465,7 @@ public static func matrixDiag<T: TensorFlowScalar>(
 ///
 /// - Output diagonal: The extracted diagonal(s) having shape
 ///   `diagonal.shape = input.shape[:-2] + [min(input.shape[-2:])]`.
-@inlinable @inline(__always)
+@inlinable
 public static func matrixDiagPart<T: TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -15501,7 +15476,7 @@ public static func matrixDiagPart<T: TensorFlowScalar>(
 }
 
 /// Deprecated, use python implementation tf.linalg.matrix_exponential.
-@inlinable @inline(__always)
+@inlinable
 public static func matrixExponential<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -15532,7 +15507,7 @@ public static func matrixExponential<T: FloatingPoint & TensorFlowScalar>(
 ///   @compatibility(numpy)
 ///   Equivalent to np.linalg.inv
 ///   @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func matrixInverse<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   adjoint: Bool = false
@@ -15569,7 +15544,7 @@ public static func matrixInverse<T: FloatingPoint & TensorFlowScalar>(
 ///   @compatibility(scipy)
 ///   Equivalent to scipy.linalg.logm
 ///   @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func matrixLogarithm<T: TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -15599,7 +15574,7 @@ public static func matrixLogarithm<T: TensorFlowScalar>(
 ///   - diagonal: Rank `k`, where `k >= 1`.
 ///
 /// - Output output: Rank `k+1`, with `output.shape = input.shape`.
-@inlinable @inline(__always)
+@inlinable
 public static func matrixSetDiag<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   diagonal: Tensor<T>
@@ -15628,7 +15603,7 @@ public static func matrixSetDiag<T: TensorFlowScalar>(
 ///   adjoint.
 ///
 /// - Output output: Shape is `[..., M, K]`.
-@inlinable @inline(__always)
+@inlinable
 public static func matrixSolve<T: FloatingPoint & TensorFlowScalar>(
   matrix: Tensor<T>,
   rhs: Tensor<T>,
@@ -15689,7 +15664,7 @@ public static func matrixSolve<T: FloatingPoint & TensorFlowScalar>(
 ///     @end_compatibility
 ///
 /// - Output output: Shape is `[..., N, K]`.
-@inlinable @inline(__always)
+@inlinable
 public static func matrixSolveLs<T: FloatingPoint & TensorFlowScalar>(
   matrix: Tensor<T>,
   rhs: Tensor<T>,
@@ -15730,7 +15705,7 @@ public static func matrixSolveLs<T: FloatingPoint & TensorFlowScalar>(
 ///   @compatibility(scipy)
 ///   Equivalent to scipy.linalg.sqrtm
 ///   @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func matrixSquareRoot<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -15773,7 +15748,7 @@ public static func matrixSquareRoot<T: FloatingPoint & TensorFlowScalar>(
 ///     @end_compatibility
 ///
 /// - Output output: Shape is `[..., M, K]`.
-@inlinable @inline(__always)
+@inlinable
 public static func matrixTriangularSolve<T: FloatingPoint & TensorFlowScalar>(
   matrix: Tensor<T>,
   rhs: Tensor<T>,
@@ -15804,7 +15779,7 @@ public static func matrixTriangularSolve<T: FloatingPoint & TensorFlowScalar>(
 /// - Attr keep_dims: If true, retain reduced dimensions with length 1.
 ///
 /// - Output output: The reduced tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func max<
     T: Numeric & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -15838,7 +15813,7 @@ public static func max<
 ///         [batch, in_channels, in_height, in_width].
 ///
 /// - Output output: The max pooled output tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func maxPool<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   ksize: [Int32],
@@ -15873,7 +15848,7 @@ public static func maxPool<T: Numeric & TensorFlowScalar>(
 ///         [batch, in_channels, in_depth, in_height, in_width].
 ///
 /// - Output output: The max pooled output tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func maxPool3D<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   ksize: [Int32],
@@ -15909,7 +15884,7 @@ public static func maxPool3D<T: FloatingPoint & TensorFlowScalar>(
 ///         [batch, in_depth, in_height, in_width, in_channels].
 ///     Alternatively, the format could be "NCDHW", the data storage order is:
 ///         [batch, in_channels, in_depth, in_height, in_width].
-@inlinable @inline(__always)
+@inlinable
 public static func maxPool3DGrad<
     T: FloatingPoint & TensorFlowScalar,
     Tinput: FloatingPoint & TensorFlowScalar
@@ -15955,7 +15930,7 @@ public static func maxPool3DGrad<
 ///         [batch, in_channels, in_depth, in_height, in_width].
 ///
 /// - Output output: Gradients of gradients w.r.t. the input to `max_pool`.
-@inlinable @inline(__always)
+@inlinable
 public static func maxPool3DGradGrad<T: Numeric & TensorFlowScalar>(
   origInput: Tensor<T>,
   origOutput: Tensor<T>,
@@ -15996,7 +15971,7 @@ public static func maxPool3DGradGrad<T: Numeric & TensorFlowScalar>(
 ///         [batch, in_channels, in_height, in_width].
 ///
 /// - Output output: Gradients w.r.t. the input to `max_pool`.
-@inlinable @inline(__always)
+@inlinable
 public static func maxPoolGrad<T: Numeric & TensorFlowScalar>(
   origInput: Tensor<T>,
   origOutput: Tensor<T>,
@@ -16037,7 +16012,7 @@ public static func maxPoolGrad<T: Numeric & TensorFlowScalar>(
 ///         [batch, in_channels, in_height, in_width].
 ///
 /// - Output output: Gradients of gradients w.r.t. the input to `max_pool`.
-@inlinable @inline(__always)
+@inlinable
 public static func maxPoolGradGrad<T: Numeric & TensorFlowScalar>(
   origInput: Tensor<T>,
   origOutput: Tensor<T>,
@@ -16078,7 +16053,7 @@ public static func maxPoolGradGrad<T: Numeric & TensorFlowScalar>(
 ///         [batch, in_channels, in_height, in_width].
 ///
 /// - Output output: Gradients of gradients w.r.t. the input to `max_pool`.
-@inlinable @inline(__always)
+@inlinable
 public static func maxPoolGradGradV2<T: Numeric & TensorFlowScalar>(
   origInput: Tensor<T>,
   origOutput: Tensor<T>,
@@ -16116,7 +16091,7 @@ public static func maxPoolGradGradV2<T: Numeric & TensorFlowScalar>(
 ///   - include_batch_in_index: Whether to include batch dimension in flattened index of `argmax`.
 ///
 /// - Output output: Gradients of gradients w.r.t. the input of `max_pool`.
-@inlinable @inline(__always)
+@inlinable
 public static func maxPoolGradGradWithArgmax<
     Targmax: BinaryInteger & TensorFlowScalar,
     T: Numeric & TensorFlowScalar
@@ -16161,7 +16136,7 @@ public static func maxPoolGradGradWithArgmax<
 ///         [batch, in_channels, in_height, in_width].
 ///
 /// - Output output: Gradients w.r.t. the input to `max_pool`.
-@inlinable @inline(__always)
+@inlinable
 public static func maxPoolGradV2<T: Numeric & TensorFlowScalar>(
   origInput: Tensor<T>,
   origOutput: Tensor<T>,
@@ -16199,7 +16174,7 @@ public static func maxPoolGradV2<T: Numeric & TensorFlowScalar>(
 ///   - include_batch_in_index: Whether to include batch dimension in flattened index of `argmax`.
 ///
 /// - Output output: Gradients w.r.t. the input of `max_pool`.
-@inlinable @inline(__always)
+@inlinable
 public static func maxPoolGradWithArgmax<
     Targmax: BinaryInteger & TensorFlowScalar,
     T: Numeric & TensorFlowScalar
@@ -16242,7 +16217,7 @@ public static func maxPoolGradWithArgmax<
 ///         [batch, in_channels, in_height, in_width].
 ///
 /// - Output output: The max pooled output tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func maxPoolV2<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   ksize: Tensor<Int32>,
@@ -16284,7 +16259,7 @@ public static func maxPoolV2<T: Numeric & TensorFlowScalar>(
 /// - Outputs:
 ///   - output: The max pooled output tensor.
 ///   - argmax: 4-D.  The flattened indices of the max values chosen for each output.
-@inlinable @inline(__always)
+@inlinable
 public static func maxPoolWithArgmax<
     Targmax: BinaryInteger & TensorFlowScalar,
     T: Numeric & TensorFlowScalar
@@ -16310,7 +16285,7 @@ public static func maxPoolWithArgmax<
 ///
 /// *NOTE*: `Maximum` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func maximum<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -16337,7 +16312,7 @@ public static func maximum<T: Numeric & TensorFlowScalar>(
 /// - Attr keep_dims: If true, retain reduced dimensions with length 1.
 ///
 /// - Output output: The reduced tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func mean<
     T: Numeric & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -16368,7 +16343,7 @@ public static func mean<
 /// - Outputs:
 ///   - output: Will be set to the available input tensor.
 ///   - value_index: The index of the chosen input tensor in `inputs`.
-@inlinable @inline(__always)
+@inlinable
 public static func merge<T: TensorFlowScalar>(
   inputs: [Tensor<T>]
 ) -> (output: Tensor<T>, valueIndex: Tensor<Int32>) {
@@ -16393,7 +16368,7 @@ public static func merge<T: TensorFlowScalar>(
 ///   buffers.
 ///
 /// - Output summary: Scalar. Serialized `Summary` protocol buffer.
-@inlinable @inline(__always)
+@inlinable
 public static func mergeSummary(
   inputs: [StringTensor]
 ) -> StringTensor {
@@ -16420,7 +16395,7 @@ public static func mergeSummary(
 ///     as one of the checkpoint_prefixes.
 ///
 /// - Attr delete_old_dirs: see above.
-@inlinable @inline(__always)
+@inlinable
 public static func mergeV2Checkpoints(
   checkpointPrefixes: StringTensor,
   destinationPrefix: StringTensor,
@@ -16454,7 +16429,7 @@ public static func mergeV2Checkpoints(
 ///     ceptstrum.
 ///   - filterbank_channel_count: Resolution of the Mel bank used internally.
 ///   - dct_coefficient_count: How many output channels to produce per time slice.
-@inlinable @inline(__always)
+@inlinable
 public static func mfcc(
   spectrogram: Tensor<Float>,
   sampleRate: Tensor<Int32>,
@@ -16488,7 +16463,7 @@ public static func mfcc(
 /// - Attr keep_dims: If true, retain reduced dimensions with length 1.
 ///
 /// - Output output: The reduced tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func min<
     T: Numeric & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -16510,7 +16485,7 @@ public static func min<
 ///
 /// *NOTE*: `Minimum` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func minimum<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -16562,7 +16537,7 @@ public static func minimum<T: Numeric & TensorFlowScalar>(
 ///   it is `[1, 2, 3, 3, 2]` in symmetric mode.
 ///
 /// - Output output: The padded tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func mirrorPad<
     T: TensorFlowScalar,
     Tpaddings: BinaryInteger & TensorFlowScalar
@@ -16609,7 +16584,7 @@ public static func mirrorPad<
 /// - Attr mode: The mode used in the `MirrorPad` op.
 ///
 /// - Output output: The folded tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func mirrorPadGrad<
     T: TensorFlowScalar,
     Tpaddings: BinaryInteger & TensorFlowScalar
@@ -16627,7 +16602,7 @@ public static func mirrorPadGrad<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func mixedStruct(
   nA: Int64
 ) -> (a: [Tensor<Int32>], b: Tensor<Float>) {
@@ -16643,7 +16618,7 @@ public static func mixedStruct(
 ///
 /// *NOTE*: `Mod` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func mod<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -16660,7 +16635,7 @@ public static func mod<T: Numeric & TensorFlowScalar>(
 /// Identity transformation that models performance.
 ///
 /// - Parameter input_dataset: A variant tensor representing the input dataset.
-@inlinable @inline(__always)
+@inlinable
 public static func modelDataset(
   inputDataset: VariantHandle,
   cpuBudget: Int64 = 0,
@@ -16679,7 +16654,7 @@ public static func modelDataset(
 ///
 /// *NOTE*: `Multiply` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func mul<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -16695,7 +16670,7 @@ public static func mul<T: Numeric & TensorFlowScalar>(
 ///
 /// *NOTE*: `Mul` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func mulNoNan<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -16719,7 +16694,7 @@ public static func mulNoNan<T: FloatingPoint & TensorFlowScalar>(
 ///   - output_shapes: The list of shapes being produced.
 ///
 /// - Output handle: Handle to the resource created.
-@inlinable @inline(__always)
+@inlinable
 public static func multiDeviceIterator(
   devices: [String],
   sharedName: String,
@@ -16745,7 +16720,7 @@ public static func multiDeviceIterator(
 ///   - output_shapes: The list of shapes being produced.
 ///
 /// - Output multi_device_iterator: A MultiDeviceIterator resource.
-@inlinable @inline(__always)
+@inlinable
 public static func multiDeviceIteratorFromStringHandle(
   stringHandle: StringTensor,
   outputTypes: [TensorDataType],
@@ -16770,7 +16745,7 @@ public static func multiDeviceIteratorFromStringHandle(
 ///   - output_shapes: The list of shapes being produced.
 ///
 /// - Output components: Result of the get_next on the dataset.
-@inlinable @inline(__always)
+@inlinable
 public static func multiDeviceIteratorGetNextFromShard<OutputTypes: TensorGroup>(
   multiDeviceIterator: ResourceHandle,
   shardNum: Tensor<Int32>,
@@ -16795,7 +16770,7 @@ public static func multiDeviceIteratorGetNextFromShard<OutputTypes: TensorGroup>
 ///
 /// - Output incarnation_id: An int64 indicating which incarnation of the MultiDeviceIterator
 ///   is running.
-@inlinable @inline(__always)
+@inlinable
 public static func multiDeviceIteratorInit(
   dataset: VariantHandle,
   multiDeviceIterator: ResourceHandle,
@@ -16813,7 +16788,7 @@ public static func multiDeviceIteratorInit(
 /// - Parameter multi_device_iterator: A MultiDeviceIterator resource.
 ///
 /// - Output string_handle: A string representing the resource.
-@inlinable @inline(__always)
+@inlinable
 public static func multiDeviceIteratorToStringHandle(
   multiDeviceIterator: ResourceHandle
 ) -> StringTensor {
@@ -16836,7 +16811,7 @@ public static func multiDeviceIteratorToStringHandle(
 ///
 /// - Output output: 2-D Tensor with shape `[batch_size, num_samples]`.  Each slice `[i, :]`
 ///   contains the drawn class labels with range `[0, num_classes)`.
-@inlinable @inline(__always)
+@inlinable
 public static func multinomial<
     T: Numeric & TensorFlowScalar,
     OutputDtype: BinaryInteger & TensorFlowScalar
@@ -16882,7 +16857,7 @@ public static func multinomial<
 ///     buckets before growing the table. Must be between 0 and 1.
 ///
 /// - Output table_handle: Handle to a table.
-@inlinable @inline(__always)
+@inlinable
 public static func mutableDenseHashTableV2<KeyDtype: TensorFlowScalar>(
   emptyKey: Tensor<KeyDtype>,
   deletedKey: Tensor<KeyDtype>,
@@ -16923,7 +16898,7 @@ public static func mutableDenseHashTableV2<KeyDtype: TensorFlowScalar>(
 ///   - value_dtype: Type of the table values.
 ///
 /// - Output table_handle: Handle to a table.
-@inlinable @inline(__always)
+@inlinable
 public static func mutableHashTableOfTensorsV2(
   container: String,
   sharedName: String,
@@ -16959,7 +16934,7 @@ public static func mutableHashTableOfTensorsV2(
 ///   - value_dtype: Type of the table values.
 ///
 /// - Output table_handle: Handle to a table.
-@inlinable @inline(__always)
+@inlinable
 public static func mutableHashTableV2(
   container: String,
   sharedName: String,
@@ -17022,7 +16997,7 @@ public static func mutableHashTableV2(
 /// - Output mutex_lock: A tensor that keeps a shared pointer to a lock on the mutex;
 ///   when the Tensor is destroyed, the use count on the shared pointer is decreased
 ///   by 1.  When it reaches 0, the lock is released.
-@inlinable @inline(__always)
+@inlinable
 public static func mutexLock(
   mutex: ResourceHandle
 ) -> VariantHandle {
@@ -17040,7 +17015,7 @@ public static func mutexLock(
 ///     with this shared_name. Otherwise, the node name is used instead.
 ///
 /// - Output resource: The mutex resource.
-@inlinable @inline(__always)
+@inlinable
 public static func mutexV2(
   container: String,
   sharedName: String
@@ -17051,7 +17026,7 @@ public static func mutexV2(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nInPolymorphicTwice<T: TensorFlowScalar>(
   _ a: [Tensor<T>],
   _ b: [Tensor<T>]
@@ -17064,7 +17039,7 @@ public static func nInPolymorphicTwice<T: TensorFlowScalar>(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nInTwice(
   _ a: [Tensor<Int32>],
   _ b: [StringTensor]
@@ -17076,7 +17051,7 @@ public static func nInTwice(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nInTwoTypeVariables<
     S: TensorFlowScalar,
     T: TensorFlowScalar
@@ -17093,7 +17068,7 @@ public static func nInTwoTypeVariables<
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nIntsIn(
   _ a: [Tensor<Int32>]
 ) {
@@ -17103,7 +17078,7 @@ public static func nIntsIn(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nIntsOut(
   n: Int64
 ) -> [Tensor<Int32>] {
@@ -17112,7 +17087,7 @@ public static func nIntsOut(
   return op.execute(Int(n))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nIntsOutDefault(
   n: Int64 = 3
 ) -> [Tensor<Int32>] {
@@ -17121,7 +17096,7 @@ public static func nIntsOutDefault(
   return op.execute(Int(n))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nPolymorphicIn<T: TensorFlowScalar>(
   _ a: [Tensor<T>]
 ) {
@@ -17132,7 +17107,7 @@ public static func nPolymorphicIn<T: TensorFlowScalar>(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nPolymorphicOut<T: TensorFlowScalar>(
   n: Int64
 ) -> [Tensor<T>] {
@@ -17142,7 +17117,7 @@ public static func nPolymorphicOut<T: TensorFlowScalar>(
   return op.execute(Int(n))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nPolymorphicOutDefault<T: TensorFlowScalar>(
   n: Int64 = 2
 ) -> [Tensor<T>] {
@@ -17152,7 +17127,7 @@ public static func nPolymorphicOutDefault<T: TensorFlowScalar>(
   return op.execute(Int(n))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nPolymorphicRestrictIn<T: TensorFlowScalar>(
   _ a: [Tensor<T>]
 ) {
@@ -17163,7 +17138,7 @@ public static func nPolymorphicRestrictIn<T: TensorFlowScalar>(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nPolymorphicRestrictIn(
   _ a: [StringTensor]
 ) {
@@ -17174,7 +17149,7 @@ public static func nPolymorphicRestrictIn(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nPolymorphicRestrictOut<T: TensorFlowScalar>(
   n: Int64
 ) -> [Tensor<T>] {
@@ -17184,7 +17159,7 @@ public static func nPolymorphicRestrictOut<T: TensorFlowScalar>(
   return op.execute(Int(n))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func nPolymorphicRestrictOut(
   n: Int64
 ) -> [StringTensor] {
@@ -17208,7 +17183,7 @@ public static func nPolymorphicRestrictOut(
 /// reduction: the reduction operation to perform.
 /// num_devices: The number of devices participating in this reduction.
 /// shared_name: Identifier that shared between ops of the same reduction.
-@inlinable @inline(__always)
+@inlinable
 public static func ncclAllReduce<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   reduction: Reduction,
@@ -17235,7 +17210,7 @@ public static func ncclAllReduce<T: Numeric & TensorFlowScalar>(
 /// output: The same as input.
 /// shape: The shape of the input tensor.
 ///
-@inlinable @inline(__always)
+@inlinable
 public static func ncclBroadcast<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   shape: TensorShape?
@@ -17257,7 +17232,7 @@ public static func ncclBroadcast<T: Numeric & TensorFlowScalar>(
 /// input: The input to the reduction.
 /// data: the value of the reduction across all `num_devices` devices.
 /// reduction: the reduction operation to perform.
-@inlinable @inline(__always)
+@inlinable
 public static func ncclReduce<T: Numeric & TensorFlowScalar>(
   _ input: [Tensor<T>],
   reduction: Reduction
@@ -17287,7 +17262,7 @@ public static func ncclReduce<T: Numeric & TensorFlowScalar>(
 ///     closest to the corresponding point, ordered by increasing distance.
 ///   - nearest_center_distances: Matrix of shape (n, min(m, k)). Each row contains the squared L2 distance to the
 ///     corresponding center in nearest_center_indices.
-@inlinable @inline(__always)
+@inlinable
 public static func nearestNeighbors(
   points: Tensor<Float>,
   centers: Tensor<Float>,
@@ -17303,7 +17278,7 @@ public static func nearestNeighbors(
 /// Computes numerical negative value element-wise.
 ///
 /// I.e., \\(y = -x\\).
-@inlinable @inline(__always)
+@inlinable
 public static func neg<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -17322,7 +17297,7 @@ public static func neg<T: Numeric & TensorFlowScalar>(
 /// @compatibility(cpp)
 /// Equivalent to C++ std::nextafter function.
 /// @end_compatibility
-@inlinable @inline(__always)
+@inlinable
 public static func nextAfter<T: FloatingPoint & TensorFlowScalar>(
   x1: Tensor<T>,
   x2: Tensor<T>
@@ -17339,7 +17314,7 @@ public static func nextAfter<T: FloatingPoint & TensorFlowScalar>(
 /// - Parameter data: The tensor to be made available to the next iteration.
 ///
 /// - Output output: The same tensor as `data`.
-@inlinable @inline(__always)
+@inlinable
 public static func nextIteration<T: TensorFlowScalar>(
   data: Tensor<T>
 ) -> Tensor<T> {
@@ -17350,7 +17325,7 @@ public static func nextIteration<T: TensorFlowScalar>(
 }
 
 /// Does nothing. Only useful as a placeholder for control edges.
-@inlinable @inline(__always)
+@inlinable
 public static func noOp(
 ) {
   let op = TFE_Op("NoOp")
@@ -17367,7 +17342,7 @@ public static func noOp(
 /// - Attr dtype: The type of the output.
 ///
 /// - Output output: Non-deterministic integer values with specified shape.
-@inlinable @inline(__always)
+@inlinable
 public static func nonDeterministicInts<
     Dtype: TensorFlowScalar,
     ShapeDtype: TensorFlowScalar
@@ -17412,7 +17387,7 @@ public static func nonDeterministicInts<
 ///
 /// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
 ///   indices from the boxes tensor, where `M <= max_output_size`.
-@inlinable @inline(__always)
+@inlinable
 public static func nonMaxSuppression(
   boxes: Tensor<Float>,
   scores: Tensor<Float>,
@@ -17459,7 +17434,7 @@ public static func nonMaxSuppression(
 ///
 /// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
 ///   indices from the boxes tensor, where `M <= max_output_size`.
-@inlinable @inline(__always)
+@inlinable
 public static func nonMaxSuppressionV2<T: FloatingPoint & TensorFlowScalar>(
   boxes: Tensor<T>,
   scores: Tensor<T>,
@@ -17508,7 +17483,7 @@ public static func nonMaxSuppressionV2<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
 ///   indices from the boxes tensor, where `M <= max_output_size`.
-@inlinable @inline(__always)
+@inlinable
 public static func nonMaxSuppressionV3<T: FloatingPoint & TensorFlowScalar>(
   boxes: Tensor<T>,
   scores: Tensor<T>,
@@ -17565,7 +17540,7 @@ public static func nonMaxSuppressionV3<T: FloatingPoint & TensorFlowScalar>(
 ///     indices from the boxes tensor, where `M <= max_output_size`.
 ///   - valid_outputs: A 0-D integer tensor representing the number of valid elements in
 ///     `selected_indices`, with the valid elements appearing first.
-@inlinable @inline(__always)
+@inlinable
 public static func nonMaxSuppressionV4<T: FloatingPoint & TensorFlowScalar>(
   boxes: Tensor<T>,
   scores: Tensor<T>,
@@ -17616,7 +17591,7 @@ public static func nonMaxSuppressionV4<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
 ///   indices from the boxes tensor, where `M <= max_output_size`.
-@inlinable @inline(__always)
+@inlinable
 public static func nonMaxSuppressionWithOverlaps(
   overlaps: Tensor<Float>,
   scores: Tensor<Float>,
@@ -17633,7 +17608,7 @@ public static func nonMaxSuppressionWithOverlaps(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func none(
 ) {
   let op = TFE_Op("None")
@@ -17645,7 +17620,7 @@ public static func none(
 ///
 /// *NOTE*: `NotEqual` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func notEqual<T: TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -17661,7 +17636,7 @@ public static func notEqual<T: TensorFlowScalar>(
 ///
 /// *NOTE*: `NotEqual` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func notEqual(
   _ x: StringTensor,
   _ y: StringTensor
@@ -17692,7 +17667,7 @@ public static func notEqual(
 ///   versa.
 ///
 /// - Output values: The `n`-th order statistic along each last dimensional slice.
-@inlinable @inline(__always)
+@inlinable
 public static func nthElement<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   n: Tensor<Int32>,
@@ -17706,7 +17681,7 @@ public static func nthElement<T: Numeric & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func old(
 ) {
   let op = TFE_Op("Old")
@@ -17813,7 +17788,7 @@ public static func old(
 /// - Attr axis: The axis to fill (default: -1, a new inner-most axis).
 ///
 /// - Output output: The one-hot tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func oneHot<
     T: TensorFlowScalar,
     Ti: BinaryInteger & TensorFlowScalar
@@ -17860,7 +17835,7 @@ public static func oneHot<
 ///
 /// - Output handle: A handle to the iterator that can be passed to an "IteratorGetNext"
 ///   op.
-@inlinable @inline(__always)
+@inlinable
 public static func oneShotIterator<DatasetfactoryIn: TensorGroup,
     DatasetfactoryOut: TensorGroup>(
   datasetFactory: (DatasetfactoryIn) -> DatasetfactoryOut,
@@ -17883,7 +17858,7 @@ public static func oneShotIterator<DatasetfactoryIn: TensorGroup,
 /// - Parameter x: a tensor of type T.
 ///
 /// - Output y: a tensor of the same shape and type as x but filled with ones.
-@inlinable @inline(__always)
+@inlinable
 public static func onesLike<T: TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -17893,7 +17868,7 @@ public static func onesLike<T: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func opWithDefaultAttr(
   defaultFloat: Double = 123
 ) -> Tensor<Int32> {
@@ -17902,7 +17877,7 @@ public static func opWithDefaultAttr(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func opWithFutureDefaultAttr(
 ) {
   let op = TFE_Op("OpWithFutureDefaultAttr")
@@ -17917,7 +17892,7 @@ public static func opWithFutureDefaultAttr(
 /// - Parameters:
 ///   - input_dataset: A variant tensor representing the input dataset.
 ///   - optimizations: A `tf.string` vector `tf.Tensor` identifying optimizations to use.
-@inlinable @inline(__always)
+@inlinable
 public static func optimizeDataset(
   inputDataset: VariantHandle,
   optimizations: StringTensor,
@@ -17935,7 +17910,7 @@ public static func optimizeDataset(
 }
 
 /// Constructs an Optional variant from a tuple of tensors.
-@inlinable @inline(__always)
+@inlinable
 public static func optionalFromValue<ToutputTypes: TensorArrayProtocol>(
   components: ToutputTypes
 ) -> VariantHandle {
@@ -17946,7 +17921,7 @@ public static func optionalFromValue<ToutputTypes: TensorArrayProtocol>(
 }
 
 /// Returns the value stored in an Optional variant or raises an error if none exists.
-@inlinable @inline(__always)
+@inlinable
 public static func optionalGetValue<OutputTypes: TensorGroup>(
   optional: VariantHandle,
   outputShapes: [TensorShape?]
@@ -17959,7 +17934,7 @@ public static func optionalGetValue<OutputTypes: TensorGroup>(
 }
 
 /// Returns true if and only if the given Optional variant has a value.
-@inlinable @inline(__always)
+@inlinable
 public static func optionalHasValue(
   optional: VariantHandle
 ) -> Tensor<Bool> {
@@ -17969,7 +17944,7 @@ public static func optionalHasValue(
 }
 
 /// Creates an Optional variant with no value.
-@inlinable @inline(__always)
+@inlinable
 public static func optionalNone(
 ) -> VariantHandle {
   let op = TFE_Op("OptionalNone")
@@ -17978,7 +17953,7 @@ public static func optionalNone(
 }
 
 /// Op removes all elements in the underlying container.
-@inlinable @inline(__always)
+@inlinable
 public static func orderedMapClear(
   capacity: Int64 = 0,
   memoryLimit: Int64 = 0,
@@ -17996,7 +17971,7 @@ public static func orderedMapClear(
 }
 
 /// Op returns the number of incomplete elements in the underlying container.
-@inlinable @inline(__always)
+@inlinable
 public static func orderedMapIncompleteSize(
   capacity: Int64 = 0,
   memoryLimit: Int64 = 0,
@@ -18018,7 +17993,7 @@ public static func orderedMapIncompleteSize(
 /// underlying container does not contain this key
 /// this op will block until it does.   This Op is optimized for
 /// performance.
-@inlinable @inline(__always)
+@inlinable
 public static func orderedMapPeek<Dtypes: TensorGroup>(
   key: Tensor<Int64>,
   indices: Tensor<Int32>,
@@ -18039,7 +18014,7 @@ public static func orderedMapPeek<Dtypes: TensorGroup>(
 }
 
 /// Op returns the number of elements in the underlying container.
-@inlinable @inline(__always)
+@inlinable
 public static func orderedMapSize(
   capacity: Int64 = 0,
   memoryLimit: Int64 = 0,
@@ -18071,7 +18046,7 @@ public static func orderedMapSize(
 ///   - container: If non-empty, this queue is placed in the given container. Otherwise,
 ///     a default container is used.
 ///   - shared_name: It is necessary to match this name to the matching Unstage Op.
-@inlinable @inline(__always)
+@inlinable
 public static func orderedMapStage<FakeDtypes: TensorArrayProtocol>(
   key: Tensor<Int64>,
   indices: Tensor<Int32>,
@@ -18099,7 +18074,7 @@ public static func orderedMapStage<FakeDtypes: TensorArrayProtocol>(
 ///
 /// from the underlying container.   If the underlying container
 /// does not contain this key, the op will block until it does.
-@inlinable @inline(__always)
+@inlinable
 public static func orderedMapUnstage<Dtypes: TensorGroup>(
   key: Tensor<Int64>,
   indices: Tensor<Int32>,
@@ -18123,7 +18098,7 @@ public static func orderedMapUnstage<Dtypes: TensorGroup>(
 ///
 /// key from the underlying container.   If the underlying container
 /// does not contain elements, the op will block until it does.
-@inlinable @inline(__always)
+@inlinable
 public static func orderedMapUnstageNoKey<Dtypes: TensorGroup>(
   indices: Tensor<Int32>,
   capacity: Int64 = 0,
@@ -18141,7 +18116,7 @@ public static func orderedMapUnstageNoKey<Dtypes: TensorGroup>(
   return op.execute(Int(1), Int(Dtypes._typeList.count))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func outT<T: TensorFlowScalar>(
 ) -> Tensor<T> {
   let op = TFE_Op("OutT")
@@ -18149,7 +18124,7 @@ public static func outT<T: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func outTypeList<T: TensorGroup>(
 ) -> T {
   let op = TFE_Op("OutTypeList")
@@ -18157,7 +18132,7 @@ public static func outTypeList<T: TensorGroup>(
   return op.execute(Int(T._typeList.count))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func outTypeListRestrict<T: TensorGroup>(
 ) -> T {
   let op = TFE_Op("OutTypeListRestrict")
@@ -18177,7 +18152,7 @@ public static func outTypeListRestrict<T: TensorGroup>(
 ///     device.
 ///
 /// - Output output: A tensor that will be read from the device outfeed.
-@inlinable @inline(__always)
+@inlinable
 public static func outfeedDequeue<Dtype: TensorFlowScalar>(
   shape: TensorShape?,
   deviceOrdinal: Int64 = -1
@@ -18202,7 +18177,7 @@ public static func outfeedDequeue<Dtype: TensorFlowScalar>(
 ///     device.
 ///
 /// - Output outputs: A list of tensors that will be read from the outfeed.
-@inlinable @inline(__always)
+@inlinable
 public static func outfeedDequeueTuple<Dtypes: TensorGroup>(
   shapes: [TensorShape?],
   deviceOrdinal: Int64 = -1
@@ -18217,7 +18192,7 @@ public static func outfeedDequeueTuple<Dtypes: TensorGroup>(
 /// Enqueue a Tensor on the computation outfeed.
 ///
 /// - Parameter input: A tensor that will be inserted into the outfeed queue.
-@inlinable @inline(__always)
+@inlinable
 public static func outfeedEnqueue<Dtype: TensorFlowScalar>(
   _ input: Tensor<Dtype>
 ) {
@@ -18231,7 +18206,7 @@ public static func outfeedEnqueue<Dtype: TensorFlowScalar>(
 ///
 /// - Parameter inputs: A list of tensors that will be inserted into the outfeed queue as an
 ///   XLA tuple.
-@inlinable @inline(__always)
+@inlinable
 public static func outfeedEnqueueTuple<Dtypes: TensorArrayProtocol>(
   inputs: Dtypes
 ) {
@@ -18269,7 +18244,7 @@ public static func outfeedEnqueueTuple<Dtypes: TensorArrayProtocol>(
 ///   valid range is `[-(R+1), R+1)`.
 ///
 /// - Output output: The packed tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func pack<T: TensorFlowScalar>(
   _ values: [Tensor<T>],
   axis: Int64 = 0
@@ -18307,7 +18282,7 @@ public static func pack<T: TensorFlowScalar>(
 ///                       [0, 0, 0, 0, 0, 0]]
 /// ```
 ///
-@inlinable @inline(__always)
+@inlinable
 public static func pad<
     T: TensorFlowScalar,
     Tpaddings: BinaryInteger & TensorFlowScalar
@@ -18349,7 +18324,7 @@ public static func pad<
 ///                       [0, 0, 2, 2, 0, 0]
 ///                       [0, 0, 0, 0, 0, 0]]
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func padV2<
     T: TensorFlowScalar,
     Tpaddings: BinaryInteger & TensorFlowScalar
@@ -18378,7 +18353,7 @@ public static func padV2<
 ///     padded to the maximum size of all batch elements.
 ///   - padding_values: A list of scalars containing the padding value to use for
 ///     each of the outputs.
-@inlinable @inline(__always)
+@inlinable
 public static func paddedBatchDataset<ToutputTypes: TensorArrayProtocol>(
   inputDataset: VariantHandle,
   batchSize: Tensor<Int64>,
@@ -18410,7 +18385,7 @@ public static func paddedBatchDataset<ToutputTypes: TensorArrayProtocol>(
 ///     each of the outputs.
 ///   - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
 ///     is smaller than desired.
-@inlinable @inline(__always)
+@inlinable
 public static func paddedBatchDatasetV2<ToutputTypes: TensorArrayProtocol>(
   inputDataset: VariantHandle,
   batchSize: Tensor<Int64>,
@@ -18457,7 +18432,7 @@ public static func paddedBatchDatasetV2<ToutputTypes: TensorArrayProtocol>(
 ///     across multiple sessions.
 ///
 /// - Output handle: The handle to the queue.
-@inlinable @inline(__always)
+@inlinable
 public static func paddingFIFOQueueV2(
   componentTypes: [TensorDataType],
   shapes: [TensorShape?],
@@ -18500,7 +18475,7 @@ public static func paddingFIFOQueueV2(
 ///   but with the number of input values in the first dimension.
 ///
 /// - Output output: The concatenated tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func parallelConcat<T: TensorFlowScalar>(
   _ values: [Tensor<T>],
   shape: TensorShape?
@@ -18576,7 +18551,7 @@ public static func parallelConcat<T: TensorFlowScalar>(
 /// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
 /// <img style="width:100%" src="https://www.tensorflow.org/images/DynamicStitch.png" alt>
 /// </div>
-@inlinable @inline(__always)
+@inlinable
 public static func parallelDynamicStitch<T: TensorFlowScalar>(
   indices: [Tensor<Int32>],
   data: [Tensor<T>]
@@ -18594,7 +18569,7 @@ public static func parallelDynamicStitch<T: TensorFlowScalar>(
 /// - Attr f: A function mapping elements of `input_dataset`, concatenated with
 ///   `other_arguments`, to a Dataset variant that contains elements matching
 ///   `output_types` and `output_shapes`.
-@inlinable @inline(__always)
+@inlinable
 public static func parallelInterleaveDatasetV2<
     FIn: TensorGroup,
     FOut: TensorGroup,
@@ -18631,7 +18606,7 @@ public static func parallelInterleaveDatasetV2<
 ///
 /// - Parameter num_parallel_calls: The number of concurrent invocations of `f` that process
 ///   elements from `input_dataset` in parallel.
-@inlinable @inline(__always)
+@inlinable
 public static func parallelMapDataset<
     FIn: TensorGroup,
     FOut: TensorGroup,
@@ -18683,7 +18658,7 @@ public static func parallelMapDataset<
 ///
 /// - Output output: A matrix of shape num_batches x samples_per_batch, filled with random
 ///   truncated normal values using the parameters for each row.
-@inlinable @inline(__always)
+@inlinable
 public static func parameterizedTruncatedNormal<
     Dtype: FloatingPoint & TensorFlowScalar,
     T: BinaryInteger & TensorFlowScalar
@@ -18753,7 +18728,7 @@ public static func parameterizedTruncatedNormal<
 ///     in the input.  Any minibatch entry with less than M blocks of elements of
 ///     length D1 * ... * DN will be padded with the corresponding default_value
 ///     scalar element along the second dimension.
-@inlinable @inline(__always)
+@inlinable
 public static func parseExample<
     SparseTypes: TensorGroup,
     Tdense: TensorArrayProtocol
@@ -18832,7 +18807,7 @@ public static func parseExample<
 ///     The shape of each Feature in the FeatureList corresponding to
 ///     feature_list_dense_key[j] must always equal
 ///     feature_list_dense_shapes[j].NumEntries().
-@inlinable @inline(__always)
+@inlinable
 public static func parseSequenceExample<
     ContextSparseTypes: TensorGroup,
     TcontextDense: TensorArrayProtocol,
@@ -18915,7 +18890,7 @@ public static func parseSequenceExample<
 ///     ..., DN), the shape of the output Tensor dense_values[j] will be (M,
 ///     D1, .., DN), where M is the number of blocks of elements of length
 ///     D1 * .... * DN, in the input.
-@inlinable @inline(__always)
+@inlinable
 public static func parseSingleExample<
     SparseTypes: TensorGroup,
     Tdense: TensorArrayProtocol
@@ -18992,7 +18967,7 @@ public static func parseSingleExample<
 ///     The shape of each Feature in the FeatureList corresponding to
 ///     feature_list_dense_key[j] must always equal
 ///     feature_list_dense_shapes[j].NumEntries().
-@inlinable @inline(__always)
+@inlinable
 public static func parseSingleSequenceExample<
     ContextSparseTypes: TensorGroup,
     TcontextDense: TensorArrayProtocol,
@@ -19040,7 +19015,7 @@ public static func parseSingleSequenceExample<
 ///   type of the serialized tensor and no implicit conversion will take place.
 ///
 /// - Output output: A Tensor of type `out_type`.
-@inlinable @inline(__always)
+@inlinable
 public static func parseTensor<OutType: TensorFlowScalar>(
   serialized: StringTensor
 ) -> Tensor<OutType> {
@@ -19063,7 +19038,7 @@ public static func parseTensor<OutType: TensorFlowScalar>(
 ///           devices, setting this op apart from the regular Call op.
 ///
 /// - Output output: A list of return values.
-@inlinable @inline(__always)
+@inlinable
 public static func partitionedCall<
     Tin: TensorArrayProtocol,
     Tout: TensorGroup,
@@ -19099,7 +19074,7 @@ public static func partitionedCall<
 ///     shape is unconstrained.
 ///
 /// - Output output: A placeholder tensor that must be replaced using the feed mechanism.
-@inlinable @inline(__always)
+@inlinable
 public static func placeholder<Dtype: TensorFlowScalar>(
   shape: TensorShape?
 ) -> Tensor<Dtype> {
@@ -19121,7 +19096,7 @@ public static func placeholder<Dtype: TensorFlowScalar>(
 ///     shape.  To be unconstrained, pass in a shape with unknown rank.
 ///
 /// - Output output: A placeholder tensor that must be replaced using the feed mechanism.
-@inlinable @inline(__always)
+@inlinable
 public static func placeholderV2<Dtype: TensorFlowScalar>(
   shape: TensorShape?
 ) -> Tensor<Dtype> {
@@ -19140,7 +19115,7 @@ public static func placeholderV2<Dtype: TensorFlowScalar>(
 ///   - shape: The (possibly partial) shape of the tensor.
 ///
 /// - Output output: A placeholder tensor that defaults to `input` if it is not fed.
-@inlinable @inline(__always)
+@inlinable
 public static func placeholderWithDefault<Dtype: TensorFlowScalar>(
   _ input: Tensor<Dtype>,
   shape: TensorShape?
@@ -19161,7 +19136,7 @@ public static func placeholderWithDefault<Dtype: TensorFlowScalar>(
 ///
 /// where \\(\psi(x)\\) is the digamma function.
 /// The polygamma function is defined only for non-negative integer orders \\a\\.
-@inlinable @inline(__always)
+@inlinable
 public static func polygamma<T: FloatingPoint & TensorFlowScalar>(
   _ a: Tensor<T>,
   _ x: Tensor<T>
@@ -19173,7 +19148,7 @@ public static func polygamma<T: FloatingPoint & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func polymorphic<T: TensorFlowScalar>(
   _ a: Tensor<T>
 ) -> Tensor<T> {
@@ -19183,7 +19158,7 @@ public static func polymorphic<T: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func polymorphicDefaultOut<T: TensorFlowScalar>(
 ) -> Tensor<T> {
   let op = TFE_Op("PolymorphicDefaultOut")
@@ -19191,7 +19166,7 @@ public static func polymorphicDefaultOut<T: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func polymorphicOut<T: TensorFlowScalar>(
 ) -> Tensor<T> {
   let op = TFE_Op("PolymorphicOut")
@@ -19207,7 +19182,7 @@ public static func polymorphicOut<T: TensorFlowScalar>(
 /// **NOTE**: It is more efficient to first `tf.bitcast` your tensors into
 /// `int32` or `int64` and perform the bitcount on the result, than to feed in
 /// 8- or 16-bit inputs and then aggregate the resulting counts.
-@inlinable @inline(__always)
+@inlinable
 public static func populationCount<T: BinaryInteger & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<UInt8> {
@@ -19227,7 +19202,7 @@ public static func populationCount<T: BinaryInteger & TensorFlowScalar>(
 /// # tensor 'y' is [[8, 16], [2, 3]]
 /// tf.pow(x, y) ==> [[256, 65536], [9, 27]]
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func pow<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -19243,7 +19218,7 @@ public static func pow<T: Numeric & TensorFlowScalar>(
 ///
 /// - Parameter buffer_size: The maximum number of elements to buffer in an iterator over
 ///   this dataset.
-@inlinable @inline(__always)
+@inlinable
 public static func prefetchDataset(
   inputDataset: VariantHandle,
   bufferSize: Tensor<Int64>,
@@ -19268,7 +19243,7 @@ public static func prefetchDataset(
 ///   - layout: A vector holding the requested layout in minor-to-major sequence. If a layout
 ///     attribute is passed but its values are all -1 the layout will be computed by
 ///     the infeed operation.
-@inlinable @inline(__always)
+@inlinable
 public static func prelinearize<Dtype: TensorFlowScalar>(
   _ input: Tensor<Dtype>,
   shape: TensorShape?,
@@ -19293,7 +19268,7 @@ public static func prelinearize<Dtype: TensorFlowScalar>(
 ///     tuple shapes in the order the shapes appear in the "shapes" input. The layout
 ///     elements for a sub-shape can be set to -1 in which case the corresponding layout
 ///     will be computed by the infeed operation.
-@inlinable @inline(__always)
+@inlinable
 public static func prelinearizeTuple<Dtypes: TensorArrayProtocol>(
   inputs: Dtypes,
   shapes: [TensorShape?],
@@ -19323,7 +19298,7 @@ public static func prelinearizeTuple<Dtypes: TensorArrayProtocol>(
 ///   this operation.
 ///
 /// - Output output: the same input tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func preventGradient<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   message: String
@@ -19349,7 +19324,7 @@ public static func preventGradient<T: TensorFlowScalar>(
 ///   - summarize: Only print this many entries of each tensor.
 ///
 /// - Output output: = The unmodified `input` tensor
-@inlinable @inline(__always)
+@inlinable
 public static func print<
     T: TensorFlowScalar,
     U: TensorArrayProtocol
@@ -19378,7 +19353,7 @@ public static func print<
 /// - Parameter input: The string scalar to print.
 ///
 /// - Attr output_stream: A string specifying the output stream or logging level to print to.
-@inlinable @inline(__always)
+@inlinable
 public static func printV2(
   _ input: StringTensor,
   outputStream: String = "stderr"
@@ -19411,7 +19386,7 @@ public static func printV2(
 ///     across multiple sessions.
 ///
 /// - Output handle: The handle to the queue.
-@inlinable @inline(__always)
+@inlinable
 public static func priorityQueueV2(
   componentTypes: [TensorDataType],
   shapes: [TensorShape?],
@@ -19443,7 +19418,7 @@ public static func priorityQueueV2(
 /// - Attr keep_dims: If true, retain reduced dimensions with length 1.
 ///
 /// - Output output: The reduced tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func prod<
     T: Numeric & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -19475,7 +19450,7 @@ public static func prod<
 ///     The length of the list specifies the number of outputs.
 ///
 /// - Output output: The outputs from the Op.
-@inlinable @inline(__always)
+@inlinable
 public static func pyFunc<
     Tin: TensorArrayProtocol,
     Tout: TensorGroup
@@ -19492,7 +19467,7 @@ public static func pyFunc<
 }
 
 /// A stateless version of PyFunc.
-@inlinable @inline(__always)
+@inlinable
 public static func pyFuncStateless<
     Tin: TensorArrayProtocol,
     Tout: TensorGroup
@@ -19533,7 +19508,7 @@ public static func pyFuncStateless<
 ///     `[..., M, M]`.
 ///   - r: Triangular factor. If `full_matrices` is `False` then shape is
 ///     `[..., P, N]`. If `full_matrices` is `True` then shape is `[..., M, N]`.
-@inlinable @inline(__always)
+@inlinable
 public static func qr<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   fullMatrices: Bool = false
@@ -19546,7 +19521,7 @@ public static func qr<T: FloatingPoint & TensorFlowScalar>(
 }
 
 /// Use QuantizeAndDequantizeV2 instead.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizeAndDequantize<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   signedInput: Bool = true,
@@ -19643,7 +19618,7 @@ public static func quantizeAndDequantize<T: FloatingPoint & TensorFlowScalar>(
 ///     *   HALF_UP: round towards positive. In this mode 7.5 rounds up to 8 and -7.5
 ///         rounds up to -7.
 ///
-@inlinable @inline(__always)
+@inlinable
 public static func quantizeAndDequantizeV2<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   inputMin: Tensor<T>,
@@ -19669,7 +19644,7 @@ public static func quantizeAndDequantizeV2<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// This is almost identical to QuantizeAndDequantizeV2, except that num_bits is a
 /// tensor, so its value can change during training.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizeAndDequantizeV3<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   inputMin: Tensor<T>,
@@ -19725,7 +19700,7 @@ public static func quantizeAndDequantizeV3<T: FloatingPoint & TensorFlowScalar>(
 /// - Outputs:
 ///   - output_min: The float value that the minimum quantized output value represents.
 ///   - output_max: The float value that the maximum quantized output value represents.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizeDownAndShrinkRange<
     Tinput: TensorFlowScalar,
     OutType: TensorFlowScalar
@@ -19852,7 +19827,7 @@ public static func quantizeDownAndShrinkRange<
 ///   - output: The quantized data produced from the float input.
 ///   - output_min: The actual minimum scalar value used for the output.
 ///   - output_max: The actual maximum scalar value used for the output.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizeV2<T: TensorFlowScalar>(
   _ input: Tensor<Float>,
   minRange: Tensor<Float>,
@@ -19884,7 +19859,7 @@ public static func quantizeV2<T: TensorFlowScalar>(
 ///
 ///     *NOTE*: `QuantizedAdd` supports limited forms of broadcasting. More about
 ///     broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedAdd<
     T1: TensorFlowScalar,
     T2: TensorFlowScalar,
@@ -19927,7 +19902,7 @@ public static func quantizedAdd<
 /// - Outputs:
 ///   - min_output: The float value that the lowest quantized output value represents.
 ///   - max_output: The float value that the highest quantized output value represents.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedAvgPool<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   minInput: Tensor<Float>,
@@ -19980,7 +19955,7 @@ public static func quantizedAvgPool<T: TensorFlowScalar>(
 ///   - variance_epsilon: A small float number to avoid dividing by 0.
 ///   - scale_after_normalization: A bool indicating whether the resulted tensor
 ///     needs to be multiplied with gamma.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedBatchNormWithGlobalNormalization<
     Tinput: TensorFlowScalar,
     OutType: TensorFlowScalar
@@ -20040,7 +20015,7 @@ public static func quantizedBatchNormWithGlobalNormalization<
 /// - Outputs:
 ///   - min_out: The float value that the lowest quantized output value represents.
 ///   - max_out: The float value that the highest quantized output value represents.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedBiasAdd<
     T1: TensorFlowScalar,
     T2: TensorFlowScalar,
@@ -20082,7 +20057,7 @@ public static func quantizedBiasAdd<
 ///     in `concat_dim` where it has the sum of the sizes.
 ///   - output_min: The float value that the minimum quantized output value represents.
 ///   - output_max: The float value that the maximum quantized output value represents.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConcat<T: TensorFlowScalar>(
   concatDim: Tensor<Int32>,
   _ values: [Tensor<T>],
@@ -20126,7 +20101,7 @@ public static func quantizedConcat<T: TensorFlowScalar>(
 /// - Outputs:
 ///   - min_output: The float value that the lowest quantized output value represents.
 ///   - max_output: The float value that the highest quantized output value represents.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConv2D<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20158,7 +20133,7 @@ public static func quantizedConv2D<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConv2DAndRelu<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20192,7 +20167,7 @@ public static func quantizedConv2DAndRelu<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConv2DAndReluAndRequantize<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20230,7 +20205,7 @@ public static func quantizedConv2DAndReluAndRequantize<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConv2DAndRequantize<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20289,7 +20264,7 @@ public static func quantizedConv2DAndRequantize<
 ///   - output: The output tensor.
 ///   - min_output: The minimum value of the final output tensor.
 ///   - max_output: The maximum value of the final output tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConv2DPerChannel<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20321,7 +20296,7 @@ public static func quantizedConv2DPerChannel<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConv2DWithBias<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20357,7 +20332,7 @@ public static func quantizedConv2DWithBias<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConv2DWithBiasAndRelu<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20393,7 +20368,7 @@ public static func quantizedConv2DWithBiasAndRelu<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConv2DWithBiasAndReluAndRequantize<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20435,7 +20410,7 @@ public static func quantizedConv2DWithBiasAndReluAndRequantize<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConv2DWithBiasAndRequantize<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20477,7 +20452,7 @@ public static func quantizedConv2DWithBiasAndRequantize<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConv2DWithBiasSignedSumAndReluAndRequantize<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20527,7 +20502,7 @@ public static func quantizedConv2DWithBiasSignedSumAndReluAndRequantize<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConv2DWithBiasSumAndRelu<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20565,7 +20540,7 @@ public static func quantizedConv2DWithBiasSumAndRelu<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedConv2DWithBiasSumAndReluAndRequantize<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20615,7 +20590,7 @@ public static func quantizedConv2DWithBiasSumAndReluAndRequantize<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedDepthwiseConv2D<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20647,7 +20622,7 @@ public static func quantizedDepthwiseConv2D<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedDepthwiseConv2DWithBias<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20681,7 +20656,7 @@ public static func quantizedDepthwiseConv2DWithBias<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedDepthwiseConv2DWithBiasAndRelu<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20715,7 +20690,7 @@ public static func quantizedDepthwiseConv2DWithBiasAndRelu<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedDepthwiseConv2DWithBiasAndReluAndRequantize<
     Tinput: TensorFlowScalar,
     Tfilter: TensorFlowScalar,
@@ -20775,7 +20750,7 @@ public static func quantizedDepthwiseConv2DWithBiasAndReluAndRequantize<
 ///   - y: A 4D Tensor.
 ///   - y_min: The value represented by the lowest quantized output.
 ///   - y_max: The value represented by the highest quantized output.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedInstanceNorm<T: TensorFlowScalar>(
   _ x: Tensor<T>,
   xMin: Tensor<Float>,
@@ -20823,7 +20798,7 @@ public static func quantizedInstanceNorm<T: TensorFlowScalar>(
 /// - Outputs:
 ///   - min_out: The float value that the lowest quantized output value represents.
 ///   - max_out: The float value that the highest quantized output value represents.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedMatMul<
     T1: TensorFlowScalar,
     T2: TensorFlowScalar,
@@ -20872,7 +20847,7 @@ public static func quantizedMatMul<
 /// - Outputs:
 ///   - min_output: The float value that the lowest quantized output value represents.
 ///   - max_output: The float value that the highest quantized output value represents.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedMaxPool<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   minInput: Tensor<Float>,
@@ -20906,7 +20881,7 @@ public static func quantizedMaxPool<T: TensorFlowScalar>(
 ///
 ///     *NOTE*: `QuantizedMul` supports limited forms of broadcasting. More about
 ///     broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedMul<
     T1: TensorFlowScalar,
     T2: TensorFlowScalar,
@@ -20942,7 +20917,7 @@ public static func quantizedMul<
 ///   - activations: Has the same output shape as "features".
 ///   - min_activations: The float value that the lowest quantized value represents.
 ///   - max_activations: The float value that the highest quantized value represents.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedRelu<
     Tinput: TensorFlowScalar,
     OutType: TensorFlowScalar
@@ -20970,7 +20945,7 @@ public static func quantizedRelu<
 ///   - activations: Has the same output shape as "features".
 ///   - min_activations: The float value that the lowest quantized value represents.
 ///   - max_activations: The float value that the highest quantized value represents.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedRelu6<
     Tinput: TensorFlowScalar,
     OutType: TensorFlowScalar
@@ -20998,7 +20973,7 @@ public static func quantizedRelu6<
 ///   - activations: Has the same output shape as "features".
 ///   - min_activations: The float value that the lowest quantized value represents.
 ///   - max_activations: The float value that the highest quantized value represents.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedReluX<
     Tinput: TensorFlowScalar,
     OutType: TensorFlowScalar
@@ -21030,7 +21005,7 @@ public static func quantizedReluX<
 /// - Outputs:
 ///   - output_min: This value is copied from input_min.
 ///   - output_max: This value is copied from input_max.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedReshape<
     T: TensorFlowScalar,
     Tshape: BinaryInteger & TensorFlowScalar
@@ -21064,7 +21039,7 @@ public static func quantizedReshape<
 ///
 /// - Output resized_images: 4-D with shape
 ///   `[batch, new_height, new_width, channels]`.
-@inlinable @inline(__always)
+@inlinable
 public static func quantizedResizeBilinear<T: FloatingPoint & TensorFlowScalar>(
   images: Tensor<T>,
   size: Tensor<Int32>,
@@ -21096,7 +21071,7 @@ public static func quantizedResizeBilinear<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Attr cancel_pending_enqueues: If true, all pending enqueue requests that are
 ///   blocked on the given queue will be canceled.
-@inlinable @inline(__always)
+@inlinable
 public static func queueCloseV2(
   handle: ResourceHandle,
   cancelPendingEnqueues: Bool = false
@@ -21134,7 +21109,7 @@ public static func queueCloseV2(
 ///     Note: This option is not supported yet.
 ///
 /// - Output components: One or more tensors that were dequeued as a tuple.
-@inlinable @inline(__always)
+@inlinable
 public static func queueDequeueManyV2<ComponentTypes: TensorGroup>(
   handle: ResourceHandle,
   n: Tensor<Int32>,
@@ -21179,7 +21154,7 @@ public static func queueDequeueManyV2<ComponentTypes: TensorGroup>(
 ///     Note: This option is not supported yet.
 ///
 /// - Output components: One or more tensors that were dequeued as a tuple.
-@inlinable @inline(__always)
+@inlinable
 public static func queueDequeueUpToV2<ComponentTypes: TensorGroup>(
   handle: ResourceHandle,
   n: Tensor<Int32>,
@@ -21211,7 +21186,7 @@ public static func queueDequeueUpToV2<ComponentTypes: TensorGroup>(
 ///     Note: This option is not supported yet.
 ///
 /// - Output components: One or more tensors that were dequeued as a tuple.
-@inlinable @inline(__always)
+@inlinable
 public static func queueDequeueV2<ComponentTypes: TensorGroup>(
   handle: ResourceHandle,
   timeoutMs: Int64 = -1
@@ -21243,7 +21218,7 @@ public static func queueDequeueV2<ComponentTypes: TensorGroup>(
 /// - Attr timeout_ms: If the queue is too full, this operation will block for up
 ///   to timeout_ms milliseconds.
 ///   Note: This option is not supported yet.
-@inlinable @inline(__always)
+@inlinable
 public static func queueEnqueueManyV2<Tcomponents: TensorArrayProtocol>(
   handle: ResourceHandle,
   components: Tcomponents,
@@ -21272,7 +21247,7 @@ public static func queueEnqueueManyV2<Tcomponents: TensorArrayProtocol>(
 /// - Attr timeout_ms: If the queue is full, this operation will block for up to
 ///   timeout_ms milliseconds.
 ///   Note: This option is not supported yet.
-@inlinable @inline(__always)
+@inlinable
 public static func queueEnqueueV2<Tcomponents: TensorArrayProtocol>(
   handle: ResourceHandle,
   components: Tcomponents,
@@ -21292,7 +21267,7 @@ public static func queueEnqueueV2<Tcomponents: TensorArrayProtocol>(
 /// is open.
 ///
 /// - Parameter handle: The handle to a queue.
-@inlinable @inline(__always)
+@inlinable
 public static func queueIsClosedV2(
   handle: ResourceHandle
 ) -> Tensor<Bool> {
@@ -21306,7 +21281,7 @@ public static func queueIsClosedV2(
 /// - Parameter handle: The handle to a queue.
 ///
 /// - Output size: The number of elements in the given queue.
-@inlinable @inline(__always)
+@inlinable
 public static func queueSizeV2(
   handle: ResourceHandle
 ) -> Tensor<Int32> {
@@ -21328,7 +21303,7 @@ public static func queueSizeV2(
 /// - Parameter images: 1-D or higher rank. RGB data to convert. Last dimension must be size 3.
 ///
 /// - Output output: `images` converted to HSV.
-@inlinable @inline(__always)
+@inlinable
 public static func rGBToHSV<T: FloatingPoint & TensorFlowScalar>(
   images: Tensor<T>
 ) -> Tensor<T> {
@@ -21385,7 +21360,7 @@ public static func rGBToHSV<T: FloatingPoint & TensorFlowScalar>(
 ///   - output_nested_splits: The `nested_row_splits` tensors that define the row-partitioning for the
 ///     returned RaggedTensor.
 ///   - output_dense_values: The `flat_values` for the returned RaggedTensor.
-@inlinable @inline(__always)
+@inlinable
 public static func raggedGather<
     Tvalues: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -21435,7 +21410,7 @@ public static func raggedGather<
 /// - Outputs:
 ///   - rt_nested_splits: The `row_splits` for the returned `RaggedTensor`.
 ///   - rt_dense_values: The `flat_values` for the returned `RaggedTensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func raggedRange<T: Numeric & TensorFlowScalar>(
   starts: Tensor<T>,
   limits: Tensor<T>,
@@ -21467,7 +21442,7 @@ public static func raggedRange<T: Numeric & TensorFlowScalar>(
 ///   - sparse_indices: The indices for the `SparseTensor`.
 ///   - sparse_values: The values of the `SparseTensor`.
 ///   - sparse_dense_shape: `sparse_dense_shape` is a tight bounding box of the input `RaggedTensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func raggedTensorToSparse<T: TensorFlowScalar>(
   rtNestedSplits: [Tensor<Int64>],
   rtDenseValues: Tensor<T>
@@ -21500,7 +21475,7 @@ public static func raggedTensorToSparse<T: TensorFlowScalar>(
 ///   - seed2: An second seed to avoid seed collision.
 ///
 /// - Output output: 3-D of shape `[crop_height, crop_width, channels].`
-@inlinable @inline(__always)
+@inlinable
 public static func randomCrop<T: Numeric & TensorFlowScalar>(
   image: Tensor<T>,
   size: Tensor<Int64>,
@@ -21537,7 +21512,7 @@ public static func randomCrop<T: Numeric & TensorFlowScalar>(
 /// - Output output: A tensor with shape `shape + shape(alpha)`. Each slice
 ///   `[:, ..., :, i0, i1, ...iN]` contains the samples drawn for
 ///   `alpha[i0, i1, ...iN]`. The dtype of the output matches the dtype of alpha.
-@inlinable @inline(__always)
+@inlinable
 public static func randomGamma<
     S: BinaryInteger & TensorFlowScalar,
     T: FloatingPoint & TensorFlowScalar
@@ -21558,7 +21533,7 @@ public static func randomGamma<
 }
 
 /// Computes the derivative of a Gamma random sample w.r.t. `alpha`.
-@inlinable @inline(__always)
+@inlinable
 public static func randomGammaGrad<T: FloatingPoint & TensorFlowScalar>(
   alpha: Tensor<T>,
   sample: Tensor<T>
@@ -21571,7 +21546,7 @@ public static func randomGammaGrad<T: FloatingPoint & TensorFlowScalar>(
 }
 
 /// Use RandomPoissonV2 instead.
-@inlinable @inline(__always)
+@inlinable
 public static func randomPoisson<
     S: BinaryInteger & TensorFlowScalar,
     Dtype: FloatingPoint & TensorFlowScalar
@@ -21618,7 +21593,7 @@ public static func randomPoisson<
 /// - Output output: A tensor with shape `shape + shape(rate)`. Each slice
 ///   `[:, ..., :, i0, i1, ...iN]` contains the samples drawn for
 ///   `rate[i0, i1, ...iN]`.
-@inlinable @inline(__always)
+@inlinable
 public static func randomPoissonV2<
     S: BinaryInteger & TensorFlowScalar,
     R: Numeric & TensorFlowScalar,
@@ -21662,7 +21637,7 @@ public static func randomPoissonV2<
 ///
 /// - Output output: A tensor of same shape and type as `value`, shuffled along its first
 ///   dimension.
-@inlinable @inline(__always)
+@inlinable
 public static func randomShuffle<T: TensorFlowScalar>(
   value: Tensor<T>,
   seed: Int64 = 0,
@@ -21698,7 +21673,7 @@ public static func randomShuffle<T: TensorFlowScalar>(
 ///     across multiple sessions.
 ///
 /// - Output handle: The handle to the queue.
-@inlinable @inline(__always)
+@inlinable
 public static func randomShuffleQueueV2(
   componentTypes: [TensorDataType],
   shapes: [TensorShape?],
@@ -21735,7 +21710,7 @@ public static func randomShuffleQueueV2(
 ///   - dtype: The type of the output.
 ///
 /// - Output output: A tensor of the specified shape filled with random normal values.
-@inlinable @inline(__always)
+@inlinable
 public static func randomStandardNormal<
     Dtype: FloatingPoint & TensorFlowScalar,
     T: BinaryInteger & TensorFlowScalar
@@ -21768,7 +21743,7 @@ public static func randomStandardNormal<
 ///   - dtype: The type of the output.
 ///
 /// - Output output: A tensor of the specified shape filled with uniform random values.
-@inlinable @inline(__always)
+@inlinable
 public static func randomUniform<
     Dtype: FloatingPoint & TensorFlowScalar,
     T: BinaryInteger & TensorFlowScalar
@@ -21808,7 +21783,7 @@ public static func randomUniform<
 ///   - seed2: A second seed to avoid seed collision.
 ///
 /// - Output output: A tensor of the specified shape filled with uniform random integers.
-@inlinable @inline(__always)
+@inlinable
 public static func randomUniformInt<
     Tout: BinaryInteger & TensorFlowScalar,
     T: BinaryInteger & TensorFlowScalar
@@ -21850,7 +21825,7 @@ public static func randomUniformInt<
 ///   - delta: 0-D (scalar). Optional. Default is 1. Number that increments `start`.
 ///
 /// - Output output: 1-D.
-@inlinable @inline(__always)
+@inlinable
 public static func range<Tidx: Numeric & TensorFlowScalar>(
   start: Tensor<Tidx>,
   limit: Tensor<Tidx>,
@@ -21870,7 +21845,7 @@ public static func range<Tidx: Numeric & TensorFlowScalar>(
 ///   - start: corresponds to start in python's xrange().
 ///   - stop: corresponds to stop in python's xrange().
 ///   - step: corresponds to step in python's xrange().
-@inlinable @inline(__always)
+@inlinable
 public static func rangeDataset(
   start: Tensor<Int64>,
   stop: Tensor<Int64>,
@@ -21902,7 +21877,7 @@ public static func rangeDataset(
 /// **Note**: The rank of a tensor is not the same as the rank of a matrix. The rank
 /// of a tensor is the number of indices required to uniquely select each element
 /// of the tensor. Rank is also known as "order", "degree", or "ndims."
-@inlinable @inline(__always)
+@inlinable
 public static func rank<T: TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<Int32> {
@@ -21913,7 +21888,7 @@ public static func rank<T: TensorFlowScalar>(
 }
 
 /// Reads and outputs the entire contents of the input filename.
-@inlinable @inline(__always)
+@inlinable
 public static func readFile(
   filename: StringTensor
 ) -> StringTensor {
@@ -21934,7 +21909,7 @@ public static func readFile(
 /// - Parameter resource: handle to the resource in which to store the variable.
 ///
 /// - Attr dtype: the dtype of the value.
-@inlinable @inline(__always)
+@inlinable
 public static func readVariableOp<Dtype: TensorFlowScalar>(
   resource: ResourceHandle
 ) -> Tensor<Dtype> {
@@ -21950,7 +21925,7 @@ public static func readVariableOp<Dtype: TensorFlowScalar>(
 /// succeeded.
 ///
 /// - Parameter reader_handle: Handle to a Reader.
-@inlinable @inline(__always)
+@inlinable
 public static func readerNumRecordsProducedV2(
   readerHandle: ResourceHandle
 ) -> Tensor<Int64> {
@@ -21962,7 +21937,7 @@ public static func readerNumRecordsProducedV2(
 /// Returns the number of work units this Reader has finished processing.
 ///
 /// - Parameter reader_handle: Handle to a Reader.
-@inlinable @inline(__always)
+@inlinable
 public static func readerNumWorkUnitsCompletedV2(
   readerHandle: ResourceHandle
 ) -> Tensor<Int64> {
@@ -21986,7 +21961,7 @@ public static func readerNumWorkUnitsCompletedV2(
 /// - Outputs:
 ///   - keys: A 1-D tensor.
 ///   - values: A 1-D tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func readerReadUpToV2(
   readerHandle: ResourceHandle,
   queueHandle: ResourceHandle,
@@ -22012,7 +21987,7 @@ public static func readerReadUpToV2(
 /// - Outputs:
 ///   - key: A scalar.
 ///   - value: A scalar.
-@inlinable @inline(__always)
+@inlinable
 public static func readerReadV2(
   readerHandle: ResourceHandle,
   queueHandle: ResourceHandle
@@ -22026,7 +22001,7 @@ public static func readerReadV2(
 /// Restore a Reader to its initial clean state.
 ///
 /// - Parameter reader_handle: Handle to a Reader.
-@inlinable @inline(__always)
+@inlinable
 public static func readerResetV2(
   readerHandle: ResourceHandle
 ) {
@@ -22044,7 +22019,7 @@ public static func readerResetV2(
 ///   - reader_handle: Handle to a Reader.
 ///   - state: Result of a ReaderSerializeState of a Reader with type
 ///     matching reader_handle.
-@inlinable @inline(__always)
+@inlinable
 public static func readerRestoreStateV2(
   readerHandle: ResourceHandle,
   state: StringTensor
@@ -22061,7 +22036,7 @@ public static func readerRestoreStateV2(
 /// Unimplemented error.
 ///
 /// - Parameter reader_handle: Handle to a Reader.
-@inlinable @inline(__always)
+@inlinable
 public static func readerSerializeStateV2(
   readerHandle: ResourceHandle
 ) -> StringTensor {
@@ -22083,7 +22058,7 @@ public static func readerSerializeStateV2(
 /// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
 /// tf.real(input) ==> [-2.25, 3.25]
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func real<
     T: TensorFlowScalar,
     Tout: FloatingPoint & TensorFlowScalar
@@ -22103,7 +22078,7 @@ public static func real<
 ///
 /// *NOTE*: `Div` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func realDiv<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -22118,7 +22093,7 @@ public static func realDiv<T: Numeric & TensorFlowScalar>(
 /// Computes the reciprocal of x element-wise.
 ///
 /// I.e., \\(y = 1 / x\\).
-@inlinable @inline(__always)
+@inlinable
 public static func reciprocal<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -22132,7 +22107,7 @@ public static func reciprocal<T: Numeric & TensorFlowScalar>(
 ///
 /// Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy`
 /// is the corresponding input gradient.
-@inlinable @inline(__always)
+@inlinable
 public static func reciprocalGrad<T: FloatingPoint & TensorFlowScalar>(
   _ y: Tensor<T>,
   dy: Tensor<T>
@@ -22158,7 +22133,7 @@ public static func reciprocalGrad<T: FloatingPoint & TensorFlowScalar>(
 ///     GZIP are supported. Defaults to none.
 ///
 /// - Output records: A tensor of shape [batch_size].
-@inlinable @inline(__always)
+@inlinable
 public static func recordInput(
   filePattern: String,
   fileRandomSeed: Int64 = 301,
@@ -22195,7 +22170,7 @@ public static func recordInput(
 ///
 /// - Output outputs: A TensorList of embedding activations containing one Tensor per
 ///   embedding table in the model.
-@inlinable @inline(__always)
+@inlinable
 public static func recvTPUEmbeddingActivations(
   numOutputs: Int64,
   config: String
@@ -22216,7 +22191,7 @@ public static func recvTPUEmbeddingActivations(
 /// - Attr f: A function that maps `(old_state, input_element)` to `new_state`. It must take
 ///   two arguments and return a nested structures of tensors. The structure of
 ///   `new_state` must match the structure of `initial_state`.
-@inlinable @inline(__always)
+@inlinable
 public static func reduceDataset<
     FIn: TensorGroup,
     FOut: TensorGroup,
@@ -22282,7 +22257,7 @@ public static func reduceDataset<
 ///
 /// - Output output: Has shape equal to that of the input with reduced dimensions removed or
 ///   set to `1` depending on `keep_dims`.
-@inlinable @inline(__always)
+@inlinable
 public static func reduceJoin(
   inputs: StringTensor,
   reductionIndices: Tensor<Int32>,
@@ -22311,7 +22286,7 @@ public static func reduceJoin(
 ///   - pattern: A scalar string tensor containing the regular expression to match the input.
 ///
 /// - Output output: A bool tensor with the same shape as `input`.
-@inlinable @inline(__always)
+@inlinable
 public static func regexFullMatch(
   _ input: StringTensor,
   pattern: StringTensor
@@ -22338,7 +22313,7 @@ public static func regexFullMatch(
 ///   substitution is only made for the first `pattern` match.
 ///
 /// - Output output: The text after applying pattern match and rewrite substitution.
-@inlinable @inline(__always)
+@inlinable
 public static func regexReplace(
   _ input: StringTensor,
   pattern: StringTensor,
@@ -22354,7 +22329,7 @@ public static func regexReplace(
 }
 
 /// Computes rectified linear: `max(features, 0)`.
-@inlinable @inline(__always)
+@inlinable
 public static func relu<T: Numeric & TensorFlowScalar>(
   features: Tensor<T>
 ) -> Tensor<T> {
@@ -22365,7 +22340,7 @@ public static func relu<T: Numeric & TensorFlowScalar>(
 }
 
 /// Computes rectified linear 6: `min(max(features, 0), 6)`.
-@inlinable @inline(__always)
+@inlinable
 public static func relu6<T: Numeric & TensorFlowScalar>(
   features: Tensor<T>
 ) -> Tensor<T> {
@@ -22384,7 +22359,7 @@ public static func relu6<T: Numeric & TensorFlowScalar>(
 ///
 /// - Output backprops: The gradients:
 ///   `gradients * (features > 0) * (features < 6)`.
-@inlinable @inline(__always)
+@inlinable
 public static func relu6Grad<T: Numeric & TensorFlowScalar>(
   gradients: Tensor<T>,
   features: Tensor<T>
@@ -22404,7 +22379,7 @@ public static func relu6Grad<T: Numeric & TensorFlowScalar>(
 ///     the outputs of that operation (both work equivalently).
 ///
 /// - Output backprops: `gradients * (features > 0)`.
-@inlinable @inline(__always)
+@inlinable
 public static func reluGrad<T: Numeric & TensorFlowScalar>(
   gradients: Tensor<T>,
   features: Tensor<T>
@@ -22428,7 +22403,7 @@ public static func reluGrad<T: Numeric & TensorFlowScalar>(
 ///   - f: The function to run remotely.
 ///
 /// - Output output: A list of return values.
-@inlinable @inline(__always)
+@inlinable
 public static func remoteCall<
     Tin: TensorArrayProtocol,
     Tout: TensorGroup,
@@ -22464,7 +22439,7 @@ public static func remoteCall<
 ///   of RemoteFusedGraphExecuteInfo which contains graph specifications.
 ///
 /// - Output outputs: Arbitrary number of tensors with arbitrary data types
-@inlinable @inline(__always)
+@inlinable
 public static func remoteFusedGraphExecute<
     Tinputs: TensorArrayProtocol,
     Toutputs: TensorGroup
@@ -22484,7 +22459,7 @@ public static func remoteFusedGraphExecute<
 ///
 /// - Parameter count: A scalar representing the number of times that `input_dataset` should
 ///   be repeated. A value of `-1` indicates that it should be repeated infinitely.
-@inlinable @inline(__always)
+@inlinable
 public static func repeatDataset(
   inputDataset: VariantHandle,
   count: Tensor<Int64>,
@@ -22515,7 +22490,7 @@ public static func repeatDataset(
 /// - Outputs:
 ///   - output_min: The computed min output.
 ///   - output_max: the computed max output.
-@inlinable @inline(__always)
+@inlinable
 public static func requantizationRange<Tinput: TensorFlowScalar>(
   _ input: Tensor<Tinput>,
   inputMin: Tensor<Float>,
@@ -22544,7 +22519,7 @@ public static func requantizationRange<Tinput: TensorFlowScalar>(
 /// - Outputs:
 ///   - output_min: The minimum value of the final output tensor
 ///   - output_max: The maximum value of the final output tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func requantizationRangePerChannel<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   inputMin: Tensor<Float>,
@@ -22583,7 +22558,7 @@ public static func requantizationRangePerChannel<T: TensorFlowScalar>(
 /// - Outputs:
 ///   - output_min: The requested_output_min value is copied into this output.
 ///   - output_max: The requested_output_max value is copied into this output.
-@inlinable @inline(__always)
+@inlinable
 public static func requantize<
     Tinput: TensorFlowScalar,
     OutType: TensorFlowScalar
@@ -22622,7 +22597,7 @@ public static func requantize<
 ///   - output: Output tensor.
 ///   - output_min: The minimum value of the final output tensor
 ///   - output_max: The maximum value of the final output tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func requantizePerChannel<
     T: TensorFlowScalar,
     OutType: TensorFlowScalar
@@ -22644,7 +22619,7 @@ public static func requantizePerChannel<
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func requiresOlderGraphVersion(
 ) -> Tensor<Int32> {
   let op = TFE_Op("RequiresOlderGraphVersion")
@@ -22652,7 +22627,7 @@ public static func requiresOlderGraphVersion(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func reservedAttr(
   range: Int64
 ) {
@@ -22661,7 +22636,7 @@ public static func reservedAttr(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func reservedInput(
   _ input: Tensor<Int32>
 ) {
@@ -22730,7 +22705,7 @@ public static func reservedInput(
 /// ```
 ///
 /// - Parameter shape: Defines the shape of the output tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func reshape<
     T: TensorFlowScalar,
     Tshape: BinaryInteger & TensorFlowScalar
@@ -22770,7 +22745,7 @@ public static func reshape<
 ///
 /// - Output resized_images: 4-D with shape
 ///   `[batch, new_height, new_width, channels]`.
-@inlinable @inline(__always)
+@inlinable
 public static func resizeArea<T: Numeric & TensorFlowScalar>(
   images: Tensor<T>,
   size: Tensor<Int32>,
@@ -22798,7 +22773,7 @@ public static func resizeArea<T: Numeric & TensorFlowScalar>(
 ///
 /// - Output resized_images: 4-D with shape
 ///   `[batch, new_height, new_width, channels]`.
-@inlinable @inline(__always)
+@inlinable
 public static func resizeBicubic<T: Numeric & TensorFlowScalar>(
   images: Tensor<T>,
   size: Tensor<Int32>,
@@ -22827,7 +22802,7 @@ public static func resizeBicubic<T: Numeric & TensorFlowScalar>(
 /// - Output output: 4-D with shape `[batch, orig_height, orig_width, channels]`.
 ///   Gradients with respect to the input image. Input image must have been
 ///   float or double.
-@inlinable @inline(__always)
+@inlinable
 public static func resizeBicubicGrad<T: FloatingPoint & TensorFlowScalar>(
   grads: Tensor<Float>,
   originalImage: Tensor<T>,
@@ -22857,7 +22832,7 @@ public static func resizeBicubicGrad<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output resized_images: 4-D with shape
 ///   `[batch, new_height, new_width, channels]`.
-@inlinable @inline(__always)
+@inlinable
 public static func resizeBilinear<T: Numeric & TensorFlowScalar>(
   images: Tensor<T>,
   size: Tensor<Int32>,
@@ -22886,7 +22861,7 @@ public static func resizeBilinear<T: Numeric & TensorFlowScalar>(
 /// - Output output: 4-D with shape `[batch, orig_height, orig_width, channels]`.
 ///   Gradients with respect to the input image. Input image must have been
 ///   float or double.
-@inlinable @inline(__always)
+@inlinable
 public static func resizeBilinearGrad<T: FloatingPoint & TensorFlowScalar>(
   grads: Tensor<Float>,
   originalImage: Tensor<T>,
@@ -22914,7 +22889,7 @@ public static func resizeBilinearGrad<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output resized_images: 4-D with shape
 ///   `[batch, new_height, new_width, channels]`.
-@inlinable @inline(__always)
+@inlinable
 public static func resizeNearestNeighbor<T: Numeric & TensorFlowScalar>(
   images: Tensor<T>,
   size: Tensor<Int32>,
@@ -22942,7 +22917,7 @@ public static func resizeNearestNeighbor<T: Numeric & TensorFlowScalar>(
 ///
 /// - Output output: 4-D with shape `[batch, orig_height, orig_width, channels]`. Gradients
 ///   with respect to the input image.
-@inlinable @inline(__always)
+@inlinable
 public static func resizeNearestNeighborGrad<T: Numeric & TensorFlowScalar>(
   grads: Tensor<T>,
   size: Tensor<Int32>,
@@ -22978,7 +22953,7 @@ public static func resizeNearestNeighborGrad<T: Numeric & TensorFlowScalar>(
 /// - Attr use_locking: If `True`, updating of the var, m, and v tensors will be protected
 ///   by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyAdaMax<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   m: ResourceHandle,
@@ -23024,7 +22999,7 @@ public static func resourceApplyAdaMax<T: Numeric & TensorFlowScalar>(
 ///
 /// - Attr use_locking: If True, updating of the var, accum and update_accum tensors will be protected by
 ///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyAdadelta<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   accum: ResourceHandle,
@@ -23062,7 +23037,7 @@ public static func resourceApplyAdadelta<T: Numeric & TensorFlowScalar>(
 /// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
 ///   by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyAdagrad<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   accum: ResourceHandle,
@@ -23096,7 +23071,7 @@ public static func resourceApplyAdagrad<T: Numeric & TensorFlowScalar>(
 ///
 /// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
 ///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyAdagradDA<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   gradientAccumulator: ResourceHandle,
@@ -23146,7 +23121,7 @@ public static func resourceApplyAdagradDA<T: Numeric & TensorFlowScalar>(
 ///     by a lock; otherwise the behavior is undefined, but may exhibit less
 ///     contention.
 ///   - use_nesterov: If `True`, uses the nesterov update.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyAdam<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   m: ResourceHandle,
@@ -23202,7 +23177,7 @@ public static func resourceApplyAdam<T: Numeric & TensorFlowScalar>(
 /// - Attr use_locking: If `True`, updating of the var, m, and v tensors will be protected
 ///   by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyAdamWithAmsgrad<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   m: ResourceHandle,
@@ -23252,7 +23227,7 @@ public static func resourceApplyAdamWithAmsgrad<T: Numeric & TensorFlowScalar>(
 /// - Attr use_locking: If `True`, updating of the var and m tensors is
 ///   protected by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyAddSign<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   m: ResourceHandle,
@@ -23310,7 +23285,7 @@ public static func resourceApplyAddSign<T: Numeric & TensorFlowScalar>(
 /// - Attr use_locking: If `True`, updating of the var, mg, ms, and mom tensors is
 ///   protected by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyCenteredRMSProp<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   mg: ResourceHandle,
@@ -23359,7 +23334,7 @@ public static func resourceApplyCenteredRMSProp<T: Numeric & TensorFlowScalar>(
 /// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
 ///   by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyFtrl<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   accum: ResourceHandle,
@@ -23408,7 +23383,7 @@ public static func resourceApplyFtrl<T: Numeric & TensorFlowScalar>(
 /// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
 ///   by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyFtrlV2<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   accum: ResourceHandle,
@@ -23445,7 +23420,7 @@ public static func resourceApplyFtrlV2<T: Numeric & TensorFlowScalar>(
 ///
 /// - Attr use_locking: If `True`, the subtraction will be protected by a lock;
 ///   otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyGradientDescent<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   alpha: Tensor<T>,
@@ -23482,7 +23457,7 @@ public static func resourceApplyGradientDescent<T: Numeric & TensorFlowScalar>(
 ///   - use_nesterov: If `True`, the tensor passed to compute grad will be
 ///     var + momentum * accum, so in the end, the var you get is actually
 ///     var + momentum * accum.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyKerasMomentum<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   accum: ResourceHandle,
@@ -23525,7 +23500,7 @@ public static func resourceApplyKerasMomentum<T: Numeric & TensorFlowScalar>(
 ///   - use_nesterov: If `True`, the tensor passed to compute grad will be
 ///     var - lr * momentum * accum, so in the end, the var you get is actually
 ///     var - lr * momentum * accum.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyMomentum<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   accum: ResourceHandle,
@@ -23565,7 +23540,7 @@ public static func resourceApplyMomentum<T: Numeric & TensorFlowScalar>(
 /// - Attr use_locking: If `True`, updating of the var and m tensors is
 ///   protected by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyPowerSign<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   m: ResourceHandle,
@@ -23605,7 +23580,7 @@ public static func resourceApplyPowerSign<T: Numeric & TensorFlowScalar>(
 ///
 /// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
 ///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyProximalAdagrad<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   accum: ResourceHandle,
@@ -23641,7 +23616,7 @@ public static func resourceApplyProximalAdagrad<T: Numeric & TensorFlowScalar>(
 ///
 /// - Attr use_locking: If True, the subtraction will be protected by a lock;
 ///   otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyProximalGradientDescent<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   alpha: Tensor<T>,
@@ -23686,7 +23661,7 @@ public static func resourceApplyProximalGradientDescent<T: Numeric & TensorFlowS
 /// - Attr use_locking: If `True`, updating of the var, ms, and mom tensors is protected
 ///   by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceApplyRMSProp<T: Numeric & TensorFlowScalar>(
   var_: ResourceHandle,
   ms: ResourceHandle,
@@ -23721,7 +23696,7 @@ public static func resourceApplyRMSProp<T: Numeric & TensorFlowScalar>(
 ///
 /// - Output output: A copy of the input before increment. If nothing else modifies the
 ///   input, the values produced will all be distinct.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceCountUpTo<T: BinaryInteger & TensorFlowScalar>(
   resource: ResourceHandle,
   limit: Int64
@@ -23733,7 +23708,7 @@ public static func resourceCountUpTo<T: BinaryInteger & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func resourceCreateOp(
   resource: ResourceHandle
 ) {
@@ -23757,7 +23732,7 @@ public static func resourceCreateOp(
 ///     # Higher rank indices
 ///     output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func resourceGather<
     Dtype: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -23777,7 +23752,7 @@ public static func resourceGather<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func resourceGatherNd<
     Dtype: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -23793,7 +23768,7 @@ public static func resourceGatherNd<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func resourceInitializedOp(
   resource: ResourceHandle
 ) -> Tensor<Bool> {
@@ -23828,7 +23803,7 @@ public static func resourceInitializedOp(
 ///   - resource: Should be from a `Variable` node.
 ///   - indices: A tensor of indices into the first dimension of `ref`.
 ///   - updates: A tensor of updated values to add to `ref`.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceScatterAdd<
     Dtype: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -23872,7 +23847,7 @@ public static func resourceScatterAdd<
 ///   - resource: Should be from a `Variable` node.
 ///   - indices: A tensor of indices into the first dimension of `ref`.
 ///   - updates: A tensor of updated values to add to `ref`.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceScatterDiv<
     Dtype: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -23916,7 +23891,7 @@ public static func resourceScatterDiv<
 ///   - resource: Should be from a `Variable` node.
 ///   - indices: A tensor of indices into the first dimension of `ref`.
 ///   - updates: A tensor of updated values to add to `ref`.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceScatterMax<
     Dtype: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -23960,7 +23935,7 @@ public static func resourceScatterMax<
 ///   - resource: Should be from a `Variable` node.
 ///   - indices: A tensor of indices into the first dimension of `ref`.
 ///   - updates: A tensor of updated values to add to `ref`.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceScatterMin<
     Dtype: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24004,7 +23979,7 @@ public static func resourceScatterMin<
 ///   - resource: Should be from a `Variable` node.
 ///   - indices: A tensor of indices into the first dimension of `ref`.
 ///   - updates: A tensor of updated values to add to `ref`.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceScatterMul<
     Dtype: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24068,7 +24043,7 @@ public static func resourceScatterMul<
 /// - Attr use_locking: An optional bool. Defaults to True. If True, the assignment will
 ///   be protected by a lock; otherwise the behavior is undefined,
 ///   but may exhibit less contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceScatterNdAdd<
     T: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24134,7 +24109,7 @@ public static func resourceScatterNdAdd<
 /// - Attr use_locking: An optional bool. Defaults to True. If True, the assignment will
 ///   be protected by a lock; otherwise the behavior is undefined,
 ///   but may exhibit less contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceScatterNdSub<
     T: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24202,7 +24177,7 @@ public static func resourceScatterNdSub<
 /// - Attr use_locking: An optional bool. Defaults to True. If True, the assignment will
 ///   be protected by a lock; otherwise the behavior is undefined,
 ///   but may exhibit less contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceScatterNdUpdate<
     T: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24248,7 +24223,7 @@ public static func resourceScatterNdUpdate<
 ///   - resource: Should be from a `Variable` node.
 ///   - indices: A tensor of indices into the first dimension of `ref`.
 ///   - updates: A tensor of updated values to add to `ref`.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceScatterSub<
     Dtype: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24283,7 +24258,7 @@ public static func resourceScatterSub<
 ///   - resource: Should be from a `Variable` node.
 ///   - indices: A tensor of indices into the first dimension of `ref`.
 ///   - updates: A tensor of updated values to add to `ref`.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceScatterUpdate<
     Dtype: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24314,7 +24289,7 @@ public static func resourceScatterUpdate<
 ///
 /// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
 ///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceSparseApplyAdadelta<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24360,7 +24335,7 @@ public static func resourceSparseApplyAdadelta<
 /// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
 ///   by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceSparseApplyAdagrad<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24401,7 +24376,7 @@ public static func resourceSparseApplyAdagrad<
 ///
 /// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
 ///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceSparseApplyAdagradDA<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24466,7 +24441,7 @@ public static func resourceSparseApplyAdagradDA<
 /// - Attr use_locking: If `True`, updating of the var, mg, ms, and mom tensors is
 ///   protected by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceSparseApplyCenteredRMSProp<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24523,7 +24498,7 @@ public static func resourceSparseApplyCenteredRMSProp<
 /// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
 ///   by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceSparseApplyFtrl<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24580,7 +24555,7 @@ public static func resourceSparseApplyFtrl<
 /// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
 ///   by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceSparseApplyFtrlV2<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24638,7 +24613,7 @@ public static func resourceSparseApplyFtrlV2<
 ///   - use_nesterov: If `True`, the tensor passed to compute grad will be
 ///     var + momentum * accum, so in the end, the var you get is actually
 ///     var + momentum * accum.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceSparseApplyKerasMomentum<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24690,7 +24665,7 @@ public static func resourceSparseApplyKerasMomentum<
 ///   - use_nesterov: If `True`, the tensor passed to compute grad will be
 ///     var - lr * momentum * accum, so in the end, the var you get is actually
 ///     var - lr * momentum * accum.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceSparseApplyMomentum<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24737,7 +24712,7 @@ public static func resourceSparseApplyMomentum<
 ///
 /// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
 ///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceSparseApplyProximalAdagrad<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24781,7 +24756,7 @@ public static func resourceSparseApplyProximalAdagrad<
 ///
 /// - Attr use_locking: If True, the subtraction will be protected by a lock;
 ///   otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceSparseApplyProximalGradientDescent<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24833,7 +24808,7 @@ public static func resourceSparseApplyProximalGradientDescent<
 /// - Attr use_locking: If `True`, updating of the var, ms, and mom tensors is protected
 ///   by a lock; otherwise the behavior is undefined, but may exhibit less
 ///   contention.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceSparseApplyRMSProp<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -24873,7 +24848,7 @@ public static func resourceSparseApplyRMSProp<
 ///
 /// NOTE this op currently does not support broadcasting and so `value`'s
 /// shape must be exactly the shape produced by the slice of `ref`.
-@inlinable @inline(__always)
+@inlinable
 public static func resourceStridedSliceAssign<
     T: TensorFlowScalar,
     Index: BinaryInteger & TensorFlowScalar
@@ -24905,7 +24880,7 @@ public static func resourceStridedSliceAssign<
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func resourceUsingOp(
   resource: ResourceHandle
 ) {
@@ -24945,7 +24920,7 @@ public static func resourceUsingOp(
 ///     `file_pattern`.
 ///
 /// - Output tensor: The restored tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func restore<Dt: TensorFlowScalar>(
   filePattern: StringTensor,
   tensorName: StringTensor,
@@ -24982,7 +24957,7 @@ public static func restore<Dt: TensorFlowScalar>(
 ///     `file_pattern`. See the documentation for `Restore`.
 ///
 /// - Output tensor: The restored tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func restoreSlice<Dt: TensorFlowScalar>(
   filePattern: StringTensor,
   tensorName: StringTensor,
@@ -25025,7 +25000,7 @@ public static func restoreSlice<Dt: TensorFlowScalar>(
 ///
 /// - Output tensors: shape {N}.  The restored tensors, whose shapes are read from the
 ///   checkpoint directly.
-@inlinable @inline(__always)
+@inlinable
 public static func restoreV2<Dtypes: TensorGroup>(
   prefix: StringTensor,
   tensorNames: StringTensor,
@@ -25039,7 +25014,7 @@ public static func restoreV2<Dtypes: TensorGroup>(
   return op.execute(Int(Dtypes._typeList.count))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func restrict<T: TensorFlowScalar>(
   _ a: Tensor<T>
 ) -> Tensor<T> {
@@ -25049,7 +25024,7 @@ public static func restrict<T: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func restrict(
   _ a: StringTensor
 ) -> StringTensor {
@@ -25070,7 +25045,7 @@ public static func restrict(
 ///   - parameters: Parameter parameters updated by the ADAM optimization algorithm.
 ///   - momenta: Parameter momenta updated by the ADAM optimization algorithm.
 ///   - velocities: Parameter velocities updated by the ADAM optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingADAMParameters(
   tableId: Int64 = -1,
   tableName: String,
@@ -25097,7 +25072,7 @@ public static func retrieveTPUEmbeddingADAMParameters(
 ///   - momenta: Parameter momenta updated by the ADAM optimization algorithm.
 ///   - velocities: Parameter velocities updated by the ADAM optimization algorithm.
 ///   - gradient_accumulators: Parameter gradient_accumulators updated by the ADAM optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingADAMParametersGradAccumDebug(
   tableId: Int64 = -1,
   tableName: String,
@@ -25123,7 +25098,7 @@ public static func retrieveTPUEmbeddingADAMParametersGradAccumDebug(
 ///   - parameters: Parameter parameters updated by the Adadelta optimization algorithm.
 ///   - accumulators: Parameter accumulators updated by the Adadelta optimization algorithm.
 ///   - updates: Parameter updates updated by the Adadelta optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingAdadeltaParameters(
   tableId: Int64 = -1,
   tableName: String,
@@ -25150,7 +25125,7 @@ public static func retrieveTPUEmbeddingAdadeltaParameters(
 ///   - accumulators: Parameter accumulators updated by the Adadelta optimization algorithm.
 ///   - updates: Parameter updates updated by the Adadelta optimization algorithm.
 ///   - gradient_accumulators: Parameter gradient_accumulators updated by the Adadelta optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingAdadeltaParametersGradAccumDebug(
   tableId: Int64 = -1,
   tableName: String,
@@ -25175,7 +25150,7 @@ public static func retrieveTPUEmbeddingAdadeltaParametersGradAccumDebug(
 /// - Outputs:
 ///   - parameters: Parameter parameters updated by the Adagrad optimization algorithm.
 ///   - accumulators: Parameter accumulators updated by the Adagrad optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingAdagradParameters(
   tableId: Int64 = -1,
   tableName: String,
@@ -25201,7 +25176,7 @@ public static func retrieveTPUEmbeddingAdagradParameters(
 ///   - parameters: Parameter parameters updated by the Adagrad optimization algorithm.
 ///   - accumulators: Parameter accumulators updated by the Adagrad optimization algorithm.
 ///   - gradient_accumulators: Parameter gradient_accumulators updated by the Adagrad optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingAdagradParametersGradAccumDebug(
   tableId: Int64 = -1,
   tableName: String,
@@ -25228,7 +25203,7 @@ public static func retrieveTPUEmbeddingAdagradParametersGradAccumDebug(
 ///   - ms: Parameter ms updated by the centered RMSProp optimization algorithm.
 ///   - mom: Parameter mom updated by the centered RMSProp optimization algorithm.
 ///   - mg: Parameter mg updated by the centered RMSProp optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingCenteredRMSPropParameters(
   tableId: Int64 = -1,
   tableName: String,
@@ -25254,7 +25229,7 @@ public static func retrieveTPUEmbeddingCenteredRMSPropParameters(
 ///   - parameters: Parameter parameters updated by the FTRL optimization algorithm.
 ///   - accumulators: Parameter accumulators updated by the FTRL optimization algorithm.
 ///   - linears: Parameter linears updated by the FTRL optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingFTRLParameters(
   tableId: Int64 = -1,
   tableName: String,
@@ -25281,7 +25256,7 @@ public static func retrieveTPUEmbeddingFTRLParameters(
 ///   - accumulators: Parameter accumulators updated by the FTRL optimization algorithm.
 ///   - linears: Parameter linears updated by the FTRL optimization algorithm.
 ///   - gradient_accumulators: Parameter gradient_accumulators updated by the FTRL optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingFTRLParametersGradAccumDebug(
   tableId: Int64 = -1,
   tableName: String,
@@ -25308,7 +25283,7 @@ public static func retrieveTPUEmbeddingFTRLParametersGradAccumDebug(
 ///   - accumulators: Parameter accumulators updated by the MDL Adagrad Light optimization algorithm.
 ///   - weights: Parameter weights updated by the MDL Adagrad Light optimization algorithm.
 ///   - benefits: Parameter benefits updated by the MDL Adagrad Light optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingMDLAdagradLightParameters(
   tableId: Int64 = -1,
   tableName: String,
@@ -25333,7 +25308,7 @@ public static func retrieveTPUEmbeddingMDLAdagradLightParameters(
 /// - Outputs:
 ///   - parameters: Parameter parameters updated by the Momentum optimization algorithm.
 ///   - momenta: Parameter momenta updated by the Momentum optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingMomentumParameters(
   tableId: Int64 = -1,
   tableName: String,
@@ -25359,7 +25334,7 @@ public static func retrieveTPUEmbeddingMomentumParameters(
 ///   - parameters: Parameter parameters updated by the Momentum optimization algorithm.
 ///   - momenta: Parameter momenta updated by the Momentum optimization algorithm.
 ///   - gradient_accumulators: Parameter gradient_accumulators updated by the Momentum optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingMomentumParametersGradAccumDebug(
   tableId: Int64 = -1,
   tableName: String,
@@ -25384,7 +25359,7 @@ public static func retrieveTPUEmbeddingMomentumParametersGradAccumDebug(
 /// - Outputs:
 ///   - parameters: Parameter parameters updated by the proximal Adagrad optimization algorithm.
 ///   - accumulators: Parameter accumulators updated by the proximal Adagrad optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingProximalAdagradParameters(
   tableId: Int64 = -1,
   tableName: String,
@@ -25410,7 +25385,7 @@ public static func retrieveTPUEmbeddingProximalAdagradParameters(
 ///   - parameters: Parameter parameters updated by the proximal Adagrad optimization algorithm.
 ///   - accumulators: Parameter accumulators updated by the proximal Adagrad optimization algorithm.
 ///   - gradient_accumulators: Parameter gradient_accumulators updated by the proximal Adagrad optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug(
   tableId: Int64 = -1,
   tableName: String,
@@ -25436,7 +25411,7 @@ public static func retrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug(
 ///   - parameters: Parameter parameters updated by the RMSProp optimization algorithm.
 ///   - ms: Parameter ms updated by the RMSProp optimization algorithm.
 ///   - mom: Parameter mom updated by the RMSProp optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingRMSPropParameters(
   tableId: Int64 = -1,
   tableName: String,
@@ -25463,7 +25438,7 @@ public static func retrieveTPUEmbeddingRMSPropParameters(
 ///   - ms: Parameter ms updated by the RMSProp optimization algorithm.
 ///   - mom: Parameter mom updated by the RMSProp optimization algorithm.
 ///   - gradient_accumulators: Parameter gradient_accumulators updated by the RMSProp optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingRMSPropParametersGradAccumDebug(
   tableId: Int64 = -1,
   tableName: String,
@@ -25486,7 +25461,7 @@ public static func retrieveTPUEmbeddingRMSPropParametersGradAccumDebug(
 /// used to retrieve updated parameters before saving a checkpoint.
 ///
 /// - Output parameters: Parameter parameters updated by the stochastic gradient descent optimization algorithm.
-@inlinable @inline(__always)
+@inlinable
 public static func retrieveTPUEmbeddingStochasticGradientDescentParameters(
   tableId: Int64 = -1,
   tableName: String,
@@ -25553,7 +25528,7 @@ public static func retrieveTPUEmbeddingStochasticGradientDescentParameters(
 ///   - dims: 1-D. The dimensions to reverse.
 ///
 /// - Output output: The same shape as `tensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func reverse<T: TensorFlowScalar>(
   _ tensor: Tensor<T>,
   dims: Tensor<Bool>
@@ -25617,7 +25592,7 @@ public static func reverse<T: TensorFlowScalar>(
 ///   - dims: 1-D. The dimensions to reverse.
 ///
 /// - Output output: The same shape as `tensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func reverse(
   _ tensor: StringTensor,
   dims: Tensor<Bool>
@@ -25696,7 +25671,7 @@ public static func reverse(
 ///   - batch_dim: The dimension along which reversal is performed.
 ///
 /// - Output output: The partially reversed input. It has the same shape as `input`.
-@inlinable @inline(__always)
+@inlinable
 public static func reverseSequence<
     T: TensorFlowScalar,
     Tlen: BinaryInteger & TensorFlowScalar
@@ -25771,7 +25746,7 @@ public static func reverseSequence<
 ///     `[-rank(tensor), rank(tensor))`.
 ///
 /// - Output output: The same shape as `tensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func reverseV2<
     Tidx: BinaryInteger & TensorFlowScalar,
     T: TensorFlowScalar
@@ -25842,7 +25817,7 @@ public static func reverseV2<
 ///     `[-rank(tensor), rank(tensor))`.
 ///
 /// - Output output: The same shape as `tensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func reverseV2<Tidx: BinaryInteger & TensorFlowScalar>(
   _ tensor: StringTensor,
   axis: Tensor<Tidx>
@@ -25862,7 +25837,7 @@ public static func reverseV2<Tidx: BinaryInteger & TensorFlowScalar>(
 ///
 /// If `y` is negative, or greater than or equal to than the width of `x` in bits
 /// the result is implementation defined.
-@inlinable @inline(__always)
+@inlinable
 public static func rightShift<T: BinaryInteger & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -25885,7 +25860,7 @@ public static func rightShift<T: BinaryInteger & TensorFlowScalar>(
 /// rint(0.5000001) ==> 1.0
 /// rint([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) ==> [-2., -2., -0., 0., 2., 2., 2.]
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func rint<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -25931,7 +25906,7 @@ public static func rint<T: FloatingPoint & TensorFlowScalar>(
 /// - Output output: Has the same shape and size as the input. The elements are shifted
 ///   positively (towards larger indices) by the offsets of `shift` along the
 ///   dimensions of `axis`.
-@inlinable @inline(__always)
+@inlinable
 public static func roll<
     T: TensorFlowScalar,
     Tshift: BinaryInteger & TensorFlowScalar,
@@ -25955,7 +25930,7 @@ public static func roll<
 ///
 /// Rounds half to even.  Also known as bankers rounding. If you want to round
 /// according to the current system rounding mode use std::cint.
-@inlinable @inline(__always)
+@inlinable
 public static func round<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -26037,7 +26012,7 @@ public static func round<T: Numeric & TensorFlowScalar>(
 ///     the RPC takes longer than `timeout_in_ms`.
 ///
 /// - Output response: Same shape as `request`. Serialized proto strings: the rpc responses.
-@inlinable @inline(__always)
+@inlinable
 public static func rpc(
   address: StringTensor,
   method: StringTensor,
@@ -26059,7 +26034,7 @@ public static func rpc(
 /// Computes reciprocal of square root of x element-wise.
 ///
 /// I.e., \\(y = 1 / \sqrt{x}\\).
-@inlinable @inline(__always)
+@inlinable
 public static func rsqrt<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -26073,7 +26048,7 @@ public static func rsqrt<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// Specifically, `grad = dy * -0.5 * y^3`, where `y = rsqrt(x)`, and `dy`
 /// is the corresponding input gradient.
-@inlinable @inline(__always)
+@inlinable
 public static func rsqrtGrad<T: FloatingPoint & TensorFlowScalar>(
   _ y: Tensor<T>,
   dy: Tensor<T>
@@ -26158,7 +26133,7 @@ public static func rsqrtGrad<T: FloatingPoint & TensorFlowScalar>(
 ///     `tf.slice`.
 ///   - bboxes: 3-D with shape `[1, 1, 4]` containing the distorted bounding box.
 ///     Provide as input to `tf.image.draw_bounding_boxes`.
-@inlinable @inline(__always)
+@inlinable
 public static func sampleDistortedBoundingBox<T: BinaryInteger & TensorFlowScalar>(
   imageSize: Tensor<T>,
   boundingBoxes: Tensor<Float>,
@@ -26257,7 +26232,7 @@ public static func sampleDistortedBoundingBox<T: BinaryInteger & TensorFlowScala
 ///     `tf.slice`.
 ///   - bboxes: 3-D with shape `[1, 1, 4]` containing the distorted bounding box.
 ///     Provide as input to `tf.image.draw_bounding_boxes`.
-@inlinable @inline(__always)
+@inlinable
 public static func sampleDistortedBoundingBoxV2<T: BinaryInteger & TensorFlowScalar>(
   imageSize: Tensor<T>,
   boundingBoxes: Tensor<Float>,
@@ -26290,7 +26265,7 @@ public static func sampleDistortedBoundingBoxV2<T: BinaryInteger & TensorFlowSca
 ///     that should be taken.
 ///   - seed: A scalar representing seed of random number generator.
 ///   - seed2: A scalar representing seed2 of random number generator.
-@inlinable @inline(__always)
+@inlinable
 public static func samplingDataset(
   inputDataset: VariantHandle,
   rate: Tensor<Float>,
@@ -26321,7 +26296,7 @@ public static func samplingDataset(
 ///     the tensor.
 ///   - tensor_names: Shape `[N]`. The names of the tensors to be saved.
 ///   - data: `N` tensors to save.
-@inlinable @inline(__always)
+@inlinable
 public static func save<T: TensorArrayProtocol>(
   filename: StringTensor,
   tensorNames: StringTensor,
@@ -26366,7 +26341,7 @@ public static func save<T: TensorArrayProtocol>(
 ///   - shapes_and_slices: Shape `[N]`.  The shapes and slice specifications to use when
 ///     saving the tensors.
 ///   - data: `N` tensors to save.
-@inlinable @inline(__always)
+@inlinable
 public static func saveSlices<T: TensorArrayProtocol>(
   filename: StringTensor,
   tensorNames: StringTensor,
@@ -26395,7 +26370,7 @@ public static func saveSlices<T: TensorArrayProtocol>(
 ///   - shape_and_slices: shape {N}.  The slice specs of the tensors to be saved.
 ///     Empty strings indicate that they are non-partitioned tensors.
 ///   - tensors: `N` tensors to save.
-@inlinable @inline(__always)
+@inlinable
 public static func saveV2<Dtypes: TensorArrayProtocol>(
   prefix: StringTensor,
   tensorNames: StringTensor,
@@ -26421,7 +26396,7 @@ public static func saveV2<Dtypes: TensorArrayProtocol>(
 ///   - values: Same shape as `tags.  Values for the summary.
 ///
 /// - Output summary: Scalar.  Serialized `Summary` protocol buffer.
-@inlinable @inline(__always)
+@inlinable
 public static func scalarSummary<T: Numeric & TensorFlowScalar>(
   tags: StringTensor,
   _ values: Tensor<T>
@@ -26433,7 +26408,7 @@ public static func scalarSummary<T: Numeric & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func scaleAndTranslate<T: Numeric & TensorFlowScalar>(
   images: Tensor<T>,
   size: Tensor<Int32>,
@@ -26453,7 +26428,7 @@ public static func scaleAndTranslate<T: Numeric & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func scaleAndTranslateGrad<T: FloatingPoint & TensorFlowScalar>(
   grads: Tensor<T>,
   originalImage: Tensor<T>,
@@ -26565,7 +26540,7 @@ public static func scaleAndTranslateGrad<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output output: A new tensor with the given shape and updates applied according
 ///   to the indices.
-@inlinable @inline(__always)
+@inlinable
 public static func scatterNd<
     T: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -26628,7 +26603,7 @@ public static func scatterNd<
 ///
 /// - Output output: A `Tensor` with the same shape as `input`, containing values of `input`
 ///   updated with `updates`.
-@inlinable @inline(__always)
+@inlinable
 public static func scatterNdNonAliasingAdd<
     T: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -26652,7 +26627,7 @@ public static func scatterNdNonAliasingAdd<
 ///
 /// - Output output: a (N,2) shaped matrix where N is the number of elements in the input
 ///   vector. Each row contains the low and high parts of the fingerprint.
-@inlinable @inline(__always)
+@inlinable
 public static func sdcaFprint(
   _ input: StringTensor
 ) -> Tensor<Int64> {
@@ -26720,7 +26695,7 @@ public static func sdcaFprint(
 ///     weights associated with a sparse feature group.
 ///   - out_delta_dense_weights: a list of vectors where the values are the delta
 ///     weights associated with a dense feature group.
-@inlinable @inline(__always)
+@inlinable
 public static func sdcaOptimizer(
   sparseExampleIndices: [Tensor<Int64>],
   sparseFeatureIndices: [Tensor<Int64>],
@@ -26821,7 +26796,7 @@ public static func sdcaOptimizer(
 ///     weights associated with a sparse feature group.
 ///   - out_delta_dense_weights: a list of vectors where the values are the delta
 ///     weights associated with a dense feature group.
-@inlinable @inline(__always)
+@inlinable
 public static func sdcaOptimizerV2(
   sparseExampleIndices: [Tensor<Int64>],
   sparseFeatureIndices: [Tensor<Int64>],
@@ -26894,7 +26869,7 @@ public static func sdcaOptimizerV2(
 ///
 /// - Output output: Has same shape as data, except for dimension 0 which
 ///   has size `k`, the number of segments.
-@inlinable @inline(__always)
+@inlinable
 public static func segmentMax<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -26942,7 +26917,7 @@ public static func segmentMax<
 ///
 /// - Output output: Has same shape as data, except for dimension 0 which
 ///   has size `k`, the number of segments.
-@inlinable @inline(__always)
+@inlinable
 public static func segmentMean<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -26988,7 +26963,7 @@ public static func segmentMean<
 ///
 /// - Output output: Has same shape as data, except for dimension 0 which
 ///   has size `k`, the number of segments.
-@inlinable @inline(__always)
+@inlinable
 public static func segmentMin<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -27035,7 +27010,7 @@ public static func segmentMin<
 ///
 /// - Output output: Has same shape as data, except for dimension 0 which
 ///   has size `k`, the number of segments.
-@inlinable @inline(__always)
+@inlinable
 public static func segmentProd<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -27082,7 +27057,7 @@ public static func segmentProd<
 ///
 /// - Output output: Has same shape as data, except for dimension 0 which
 ///   has size `k`, the number of segments.
-@inlinable @inline(__always)
+@inlinable
 public static func segmentSum<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -27146,7 +27121,7 @@ public static func segmentSum<
 ///   - e: = A `Tensor` with the same type and shape as `x`.
 ///
 /// - Output output: = A `Tensor` with the same type and shape as `x` and `y`.
-@inlinable @inline(__always)
+@inlinable
 public static func select<T: TensorFlowScalar>(
   condition: Tensor<Bool>,
   t: Tensor<T>,
@@ -27173,7 +27148,7 @@ public static func select<T: TensorFlowScalar>(
 /// - Parameter input: Shape is `[..., M, M]`.
 ///
 /// - Output output: Shape is `[..., M+1, M]`.
-@inlinable @inline(__always)
+@inlinable
 public static func selfAdjointEig<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -27205,7 +27180,7 @@ public static func selfAdjointEig<T: FloatingPoint & TensorFlowScalar>(
 /// - Outputs:
 ///   - e: Eigenvalues. Shape is `[N]`.
 ///   - v: Eigenvectors. Shape is `[N, N]`.
-@inlinable @inline(__always)
+@inlinable
 public static func selfAdjointEigV2<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   computeV: Bool = true
@@ -27226,7 +27201,7 @@ public static func selfAdjointEigV2<T: FloatingPoint & TensorFlowScalar>(
 /// For correct dropout, use `tf.contrib.nn.alpha_dropout`.
 ///
 /// See [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)
-@inlinable @inline(__always)
+@inlinable
 public static func selu<T: FloatingPoint & TensorFlowScalar>(
   features: Tensor<T>
 ) -> Tensor<T> {
@@ -27244,7 +27219,7 @@ public static func selu<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// - Output backprops: The gradients: `gradients * (outputs + scale * alpha)`
 ///   if outputs < 0, `scale * gradients` otherwise.
-@inlinable @inline(__always)
+@inlinable
 public static func seluGrad<T: FloatingPoint & TensorFlowScalar>(
   gradients: Tensor<T>,
   outputs: Tensor<T>
@@ -27273,7 +27248,7 @@ public static func seluGrad<T: FloatingPoint & TensorFlowScalar>(
 ///     this list should be empty.
 ///
 /// - Attr config: Serialized TPUEmbeddingConfiguration proto.
-@inlinable @inline(__always)
+@inlinable
 public static func sendTPUEmbeddingGradients(
   inputs: [Tensor<Float>],
   learningRates: [Tensor<Float>],
@@ -27294,7 +27269,7 @@ public static func sendTPUEmbeddingGradients(
 ///
 /// - Output serialized: A variant tensor storing the state of the iterator contained in the
 ///   resource.
-@inlinable @inline(__always)
+@inlinable
 public static func serializeIterator(
   resourceHandle: ResourceHandle
 ) -> VariantHandle {
@@ -27320,7 +27295,7 @@ public static func serializeIterator(
 ///
 /// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
 ///   (default) and `variant`.
-@inlinable @inline(__always)
+@inlinable
 public static func serializeManySparse<
     T: TensorFlowScalar,
     OutType: TensorFlowScalar
@@ -27355,7 +27330,7 @@ public static func serializeManySparse<
 ///
 /// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
 ///   (default) and `variant`.
-@inlinable @inline(__always)
+@inlinable
 public static func serializeManySparse<T: TensorFlowScalar>(
   sparseIndices: Tensor<Int64>,
   sparseValues: Tensor<T>,
@@ -27379,7 +27354,7 @@ public static func serializeManySparse<T: TensorFlowScalar>(
 ///
 /// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
 ///   (default) and `variant`.
-@inlinable @inline(__always)
+@inlinable
 public static func serializeSparse<
     T: TensorFlowScalar,
     OutType: TensorFlowScalar
@@ -27406,7 +27381,7 @@ public static func serializeSparse<
 ///
 /// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
 ///   (default) and `variant`.
-@inlinable @inline(__always)
+@inlinable
 public static func serializeSparse<T: TensorFlowScalar>(
   sparseIndices: Tensor<Int64>,
   sparseValues: Tensor<T>,
@@ -27428,7 +27403,7 @@ public static func serializeSparse<T: TensorFlowScalar>(
 /// - Attr T: The type of the input tensor.
 ///
 /// - Output serialized: A serialized TensorProto proto of the input tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func serializeTensor<T: TensorFlowScalar>(
   _ tensor: Tensor<T>
 ) -> StringTensor {
@@ -27455,7 +27430,7 @@ public static func serializeTensor<T: TensorFlowScalar>(
 /// - Output size: For `set` ranked `n`, this is a `Tensor` with rank `n-1`, and the same 1st
 ///   `n-1` dimensions as `set`. Each value is the number of unique elements in
 ///   the corresponding `[0...n-1]` dimension of `set`.
-@inlinable @inline(__always)
+@inlinable
 public static func setSize<T: BinaryInteger & TensorFlowScalar>(
   setIndices: Tensor<Int64>,
   setValues: Tensor<T>,
@@ -27488,7 +27463,7 @@ public static func setSize<T: BinaryInteger & TensorFlowScalar>(
 /// - Output size: For `set` ranked `n`, this is a `Tensor` with rank `n-1`, and the same 1st
 ///   `n-1` dimensions as `set`. Each value is the number of unique elements in
 ///   the corresponding `[0...n-1]` dimension of `set`.
-@inlinable @inline(__always)
+@inlinable
 public static func setSize(
   setIndices: Tensor<Int64>,
   setValues: StringTensor,
@@ -27514,7 +27489,7 @@ public static func setSize(
 /// # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
 /// shape(t) ==> [2, 2, 3]
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func shape<
     T: TensorFlowScalar,
     OutType: BinaryInteger & TensorFlowScalar
@@ -27531,7 +27506,7 @@ public static func shape<
 /// Returns shape of tensors.
 ///
 /// This operation returns N 1-D integer tensors representing shape of `input[i]s`.
-@inlinable @inline(__always)
+@inlinable
 public static func shapeN<
     T: TensorFlowScalar,
     OutType: BinaryInteger & TensorFlowScalar
@@ -27551,7 +27526,7 @@ public static func shapeN<
 /// - Parameters:
 ///   - num_shards: An integer representing the number of shards operating in parallel.
 ///   - index: An integer representing the current worker index.
-@inlinable @inline(__always)
+@inlinable
 public static func shardDataset(
   inputDataset: VariantHandle,
   numShards: Tensor<Int64>,
@@ -27571,7 +27546,7 @@ public static func shardDataset(
 /// Generate a sharded filename. The filename is printf formatted as
 ///
 ///    %s-%05d-of-%05d, basename, shard, num_shards.
-@inlinable @inline(__always)
+@inlinable
 public static func shardedFilename(
   basename: StringTensor,
   shard: Tensor<Int32>,
@@ -27585,7 +27560,7 @@ public static func shardedFilename(
 }
 
 /// Generate a glob pattern matching all sharded file names.
-@inlinable @inline(__always)
+@inlinable
 public static func shardedFilespec(
   basename: StringTensor,
   numShards: Tensor<Int32>
@@ -27610,7 +27585,7 @@ public static func shardedFilespec(
 ///   - seed2: A second scalar seed to avoid seed collision.
 ///   - count: A scalar representing the number of times the underlying dataset
 ///     should be repeated. The default is `-1`, which results in infinite repetition.
-@inlinable @inline(__always)
+@inlinable
 public static func shuffleAndRepeatDataset(
   inputDataset: VariantHandle,
   bufferSize: Tensor<Int64>,
@@ -27647,7 +27622,7 @@ public static func shuffleAndRepeatDataset(
 ///   `seed` and `seed2` inputs. If false, each iterator will be given the same
 ///   seed, and repeated iteration over this dataset will yield the exact same
 ///   sequence of results.
-@inlinable @inline(__always)
+@inlinable
 public static func shuffleDataset(
   inputDataset: VariantHandle,
   bufferSize: Tensor<Int64>,
@@ -27671,7 +27646,7 @@ public static func shuffleDataset(
 /// Shuts down a running distributed TPU system.
 ///
 /// The op returns an error if no system is running.
-@inlinable @inline(__always)
+@inlinable
 public static func shutdownDistributedTPU(
 ) {
   let op = TFE_Op("ShutdownDistributedTPU")
@@ -27682,7 +27657,7 @@ public static func shutdownDistributedTPU(
 /// Computes sigmoid of `x` element-wise.
 ///
 /// Specifically, `y = 1 / (1 + exp(-x))`.
-@inlinable @inline(__always)
+@inlinable
 public static func sigmoid<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -27696,7 +27671,7 @@ public static func sigmoid<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// Specifically, `grad = dy * y * (1 - y)`, where `y = sigmoid(x)`, and
 /// `dy` is the corresponding input gradient.
-@inlinable @inline(__always)
+@inlinable
 public static func sigmoidGrad<T: FloatingPoint & TensorFlowScalar>(
   _ y: Tensor<T>,
   dy: Tensor<T>
@@ -27713,7 +27688,7 @@ public static func sigmoidGrad<T: FloatingPoint & TensorFlowScalar>(
 /// `y = sign(x) = -1` if `x < 0`; 0 if `x == 0`; 1 if `x > 0`.
 ///
 /// For complex numbers, `y = sign(x) = x / |x|` if `x != 0`, otherwise `y = 0`.
-@inlinable @inline(__always)
+@inlinable
 public static func sign<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -27723,7 +27698,7 @@ public static func sign<T: Numeric & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func simple(
   _ a: Tensor<Int32>
 ) -> Tensor<Float> {
@@ -27732,7 +27707,7 @@ public static func simple(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func simpleStruct(
   nA: Int64
 ) -> [Tensor<Int32>] {
@@ -27742,7 +27717,7 @@ public static func simpleStruct(
 }
 
 /// Computes sin of x element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func sin<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -27753,7 +27728,7 @@ public static func sin<T: FloatingPoint & TensorFlowScalar>(
 }
 
 /// Computes hyperbolic sine of x element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func sinh<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -27774,7 +27749,7 @@ public static func sinh<T: FloatingPoint & TensorFlowScalar>(
 /// # 't' is [[[1, 1,, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]
 /// size(t) ==> 12
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func size<
     T: TensorFlowScalar,
     OutType: BinaryInteger & TensorFlowScalar
@@ -27792,7 +27767,7 @@ public static func size<
 ///
 /// - Parameter count: A scalar representing the number of elements from the `input_dataset`
 ///   that should be skipped.  If count is -1, skips everything.
-@inlinable @inline(__always)
+@inlinable
 public static func skipDataset(
   inputDataset: VariantHandle,
   count: Tensor<Int64>,
@@ -27826,7 +27801,7 @@ public static func skipDataset(
 ///   - total_words_processed: The total number of words processed so far.
 ///   - examples: A vector of word ids.
 ///   - labels: A vector of word ids.
-@inlinable @inline(__always)
+@inlinable
 public static func skipgram(
   filename: String,
   batchSize: Int64,
@@ -27859,7 +27834,7 @@ public static func skipgram(
 ///     of 'input' to slice. If size[i] is -1, all remaining elements in dimension
 ///     i are included in the slice (i.e. this is equivalent to setting
 ///     size[i] = input.dim_size(i) - begin[i]).
-@inlinable @inline(__always)
+@inlinable
 public static func slice<
     T: TensorFlowScalar,
     Index: BinaryInteger & TensorFlowScalar
@@ -27878,7 +27853,7 @@ public static func slice<
 }
 
 /// Returns a copy of the input tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func snapshot<T: TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -27897,7 +27872,7 @@ public static func snapshot<T: TensorFlowScalar>(
 /// - Parameter logits: 2-D with shape `[batch_size, num_classes]`.
 ///
 /// - Output softmax: Same shape as `logits`.
-@inlinable @inline(__always)
+@inlinable
 public static func softmax<T: FloatingPoint & TensorFlowScalar>(
   logits: Tensor<T>
 ) -> Tensor<T> {
@@ -27920,7 +27895,7 @@ public static func softmax<T: FloatingPoint & TensorFlowScalar>(
 /// - Outputs:
 ///   - loss: Per example loss (batch_size vector).
 ///   - backprop: backpropagated gradients (batch_size x num_classes matrix).
-@inlinable @inline(__always)
+@inlinable
 public static func softmaxCrossEntropyWithLogits<T: FloatingPoint & TensorFlowScalar>(
   features: Tensor<T>,
   labels: Tensor<T>
@@ -27933,7 +27908,7 @@ public static func softmaxCrossEntropyWithLogits<T: FloatingPoint & TensorFlowSc
 }
 
 /// Computes softplus: `log(exp(features) + 1)`.
-@inlinable @inline(__always)
+@inlinable
 public static func softplus<T: FloatingPoint & TensorFlowScalar>(
   features: Tensor<T>
 ) -> Tensor<T> {
@@ -27950,7 +27925,7 @@ public static func softplus<T: FloatingPoint & TensorFlowScalar>(
 ///   - features: The features passed as input to the corresponding softplus operation.
 ///
 /// - Output backprops: The gradients: `gradients / (1 + exp(-features))`.
-@inlinable @inline(__always)
+@inlinable
 public static func softplusGrad<T: FloatingPoint & TensorFlowScalar>(
   gradients: Tensor<T>,
   features: Tensor<T>
@@ -27963,7 +27938,7 @@ public static func softplusGrad<T: FloatingPoint & TensorFlowScalar>(
 }
 
 /// Computes softsign: `features / (abs(features) + 1)`.
-@inlinable @inline(__always)
+@inlinable
 public static func softsign<T: FloatingPoint & TensorFlowScalar>(
   features: Tensor<T>
 ) -> Tensor<T> {
@@ -27980,7 +27955,7 @@ public static func softsign<T: FloatingPoint & TensorFlowScalar>(
 ///   - features: The features passed as input to the corresponding softsign operation.
 ///
 /// - Output backprops: The gradients: `gradients / (1 + abs(features)) ** 2`.
-@inlinable @inline(__always)
+@inlinable
 public static func softsignGrad<T: FloatingPoint & TensorFlowScalar>(
   gradients: Tensor<T>,
   features: Tensor<T>
@@ -28089,7 +28064,7 @@ public static func softsignGrad<T: FloatingPoint & TensorFlowScalar>(
 ///
 ///     Among others, this operation is useful for reducing atrous convolution into
 ///     regular convolution.
-@inlinable @inline(__always)
+@inlinable
 public static func spaceToBatch<
     T: TensorFlowScalar,
     Tpaddings: BinaryInteger & TensorFlowScalar
@@ -28230,7 +28205,7 @@ public static func spaceToBatch<
 ///
 ///     Among others, this operation is useful for reducing atrous convolution into
 ///     regular convolution.
-@inlinable @inline(__always)
+@inlinable
 public static func spaceToBatchND<
     T: TensorFlowScalar,
     TblockShape: BinaryInteger & TensorFlowScalar,
@@ -28337,7 +28312,7 @@ public static func spaceToBatchND<
 /// ```
 ///
 /// - Attr block_size: The size of the spatial block.
-@inlinable @inline(__always)
+@inlinable
 public static func spaceToDepth<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   blockSize: Int64,
@@ -28376,7 +28351,7 @@ public static func spaceToDepth<T: TensorFlowScalar>(
 ///   - b_shape: 1-D.  The `shape` of the second `SparseTensor`, size `[ndims]` Vector.
 ///   - thresh: 0-D.  The magnitude threshold that determines if an output value/index
 ///     pair takes space.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseAdd<
     T: Numeric & TensorFlowScalar,
     Treal: Numeric & TensorFlowScalar
@@ -28422,7 +28397,7 @@ public static func sparseAdd<
 ///     non-empty values of A.
 ///   - b_val_grad: 1-D with shape `[nnz(B)]`. The gradient with respect to the
 ///     non-empty values of B.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseAddGrad<T: Numeric & TensorFlowScalar>(
   backpropValGrad: Tensor<T>,
   aIndices: Tensor<Int64>,
@@ -28494,7 +28469,7 @@ public static func sparseAddGrad<T: Numeric & TensorFlowScalar>(
 ///   - output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
 ///   - output_values: 1-D.  Non-empty values of the concatenated `SparseTensor`.
 ///   - output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseConcat<T: TensorFlowScalar>(
   indices: [Tensor<Int64>],
   _ values: [Tensor<T>],
@@ -28569,7 +28544,7 @@ public static func sparseConcat<T: TensorFlowScalar>(
 ///   - output_values: 1-D.  Non-empty values of the concatenated or hashed
 ///     `SparseTensor`.
 ///   - output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseCross<
     SparseTypes: TensorArrayProtocol,
     DenseTypes: TensorArrayProtocol,
@@ -28658,7 +28633,7 @@ public static func sparseCross<
 ///   - output_values: 1-D.  Non-empty values of the concatenated or hashed
 ///     `SparseTensor`.
 ///   - output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseCross<
     SparseTypes: TensorArrayProtocol,
     DenseTypes: TensorArrayProtocol
@@ -28707,7 +28682,7 @@ public static func sparseCross<
 ///   - dense: `R`-D.  The dense Tensor operand.
 ///
 /// - Output output: 1-D.  The `N` values that are operated on.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseDenseCwiseAdd<T: Numeric & TensorFlowScalar>(
   spIndices: Tensor<Int64>,
   spValues: Tensor<T>,
@@ -28736,7 +28711,7 @@ public static func sparseDenseCwiseAdd<T: Numeric & TensorFlowScalar>(
 ///   - dense: `R`-D.  The dense Tensor operand.
 ///
 /// - Output output: 1-D.  The `N` values that are operated on.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseDenseCwiseDiv<T: Numeric & TensorFlowScalar>(
   spIndices: Tensor<Int64>,
   spValues: Tensor<T>,
@@ -28769,7 +28744,7 @@ public static func sparseDenseCwiseDiv<T: Numeric & TensorFlowScalar>(
 ///   - dense: `R`-D.  The dense Tensor operand.
 ///
 /// - Output output: 1-D.  The `N` values that are operated on.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseDenseCwiseMul<T: Numeric & TensorFlowScalar>(
   spIndices: Tensor<Int64>,
   spValues: Tensor<T>,
@@ -28837,7 +28812,7 @@ public static func sparseDenseCwiseMul<T: Numeric & TensorFlowScalar>(
 ///   - empty_row_indicator: 1-D. whether the dense row was missing in the
 ///     input sparse tensor.
 ///   - reverse_index_map: 1-D. a map from the input indices to the output indices.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseFillEmptyRows<T: TensorFlowScalar>(
   indices: Tensor<Int64>,
   _ values: Tensor<T>,
@@ -28871,7 +28846,7 @@ public static func sparseFillEmptyRows<T: TensorFlowScalar>(
 /// - Outputs:
 ///   - d_values: 1-D.  The backprop into values.
 ///   - d_default_value: 0-D.  The backprop into default_value.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseFillEmptyRowsGrad<T: TensorFlowScalar>(
   reverseIndexMap: Tensor<Int64>,
   gradValues: Tensor<T>
@@ -28894,7 +28869,7 @@ public static func sparseFillEmptyRowsGrad<T: TensorFlowScalar>(
 ///
 /// The gradient computation of this operation will only take advantage of sparsity
 /// in the input gradient when that gradient comes from a Relu.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseMatMul<
     Ta: FloatingPoint & TensorFlowScalar,
     Tb: FloatingPoint & TensorFlowScalar
@@ -28943,7 +28918,7 @@ public static func sparseMatMul<
 /// - Attr keep_dims: If true, retain reduced dimensions with length 1.
 ///
 /// - Output output: `R-K`-D.  The reduced Tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseReduceMax<T: Numeric & TensorFlowScalar>(
   inputIndices: Tensor<Int64>,
   inputValues: Tensor<T>,
@@ -28984,7 +28959,7 @@ public static func sparseReduceMax<T: Numeric & TensorFlowScalar>(
 ///   - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
 ///
 /// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseReduceMaxSparse<T: Numeric & TensorFlowScalar>(
   inputIndices: Tensor<Int64>,
   inputValues: Tensor<T>,
@@ -29027,7 +29002,7 @@ public static func sparseReduceMaxSparse<T: Numeric & TensorFlowScalar>(
 /// - Attr keep_dims: If true, retain reduced dimensions with length 1.
 ///
 /// - Output output: `R-K`-D.  The reduced Tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseReduceSum<T: Numeric & TensorFlowScalar>(
   inputIndices: Tensor<Int64>,
   inputValues: Tensor<T>,
@@ -29068,7 +29043,7 @@ public static func sparseReduceSum<T: Numeric & TensorFlowScalar>(
 ///   - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
 ///
 /// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseReduceSumSparse<T: Numeric & TensorFlowScalar>(
   inputIndices: Tensor<Int64>,
   inputValues: Tensor<T>,
@@ -29107,7 +29082,7 @@ public static func sparseReduceSumSparse<T: Numeric & TensorFlowScalar>(
 ///   - output_indices: 2-D.  `N x R` matrix with the same indices as input_indices, but
 ///     in canonical row-major ordering.
 ///   - output_values: 1-D.  `N` non-empty values corresponding to `output_indices`.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseReorder<T: TensorFlowScalar>(
   inputIndices: Tensor<Int64>,
   inputValues: Tensor<T>,
@@ -29151,7 +29126,7 @@ public static func sparseReorder<T: TensorFlowScalar>(
 ///   - output_shape: 1-D.  `R_out` vector with the full dense shape of the output
 ///     SparseTensor.  This is the same as `new_shape` but with any -1 dimensions
 ///     filled in.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseReshape(
   inputIndices: Tensor<Int64>,
   inputShape: Tensor<Int64>,
@@ -29177,7 +29152,7 @@ public static func sparseReshape(
 ///
 /// - Output output: Has same shape as data, except for dimension 0 which
 ///   has size `k`, the number of segments.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSegmentMean<
     T: FloatingPoint & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -29205,7 +29180,7 @@ public static func sparseSegmentMean<
 ///   - indices: indices passed to the corresponding SparseSegmentMean op.
 ///   - segment_ids: segment_ids passed to the corresponding SparseSegmentMean op.
 ///   - output_dim0: dimension 0 of "data" passed to SparseSegmentMean op.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSegmentMeanGrad<
     T: FloatingPoint & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -29241,7 +29216,7 @@ public static func sparseSegmentMeanGrad<
 ///
 /// - Output output: Has same shape as data, except for dimension 0 which has size
 ///   `num_segments`.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSegmentMeanWithNumSegments<
     T: FloatingPoint & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar,
@@ -29276,7 +29251,7 @@ public static func sparseSegmentMeanWithNumSegments<
 ///
 /// - Output output: Has same shape as data, except for dimension 0 which
 ///   has size `k`, the number of segments.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSegmentSqrtN<
     T: FloatingPoint & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -29304,7 +29279,7 @@ public static func sparseSegmentSqrtN<
 ///   - indices: indices passed to the corresponding SparseSegmentSqrtN op.
 ///   - segment_ids: segment_ids passed to the corresponding SparseSegmentSqrtN op.
 ///   - output_dim0: dimension 0 of "data" passed to SparseSegmentSqrtN op.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSegmentSqrtNGrad<
     T: FloatingPoint & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -29342,7 +29317,7 @@ public static func sparseSegmentSqrtNGrad<
 ///
 /// - Output output: Has same shape as data, except for dimension 0 which
 ///   has size `k`, the number of segments.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSegmentSqrtNWithNumSegments<
     T: FloatingPoint & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar,
@@ -29402,7 +29377,7 @@ public static func sparseSegmentSqrtNWithNumSegments<
 ///
 /// - Output output: Has same shape as data, except for dimension 0 which
 ///   has size `k`, the number of segments.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSegmentSum<
     T: Numeric & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -29457,7 +29432,7 @@ public static func sparseSegmentSum<
 ///
 /// - Output output: Has same shape as data, except for dimension 0 which
 ///   has size `num_segments`.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSegmentSumWithNumSegments<
     T: Numeric & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar,
@@ -29511,7 +29486,7 @@ public static func sparseSegmentSumWithNumSegments<
 ///     tensors.
 ///   - output_shape: A list of 1-D tensors represents the shape of the output sparse
 ///     tensors.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSlice<T: TensorFlowScalar>(
   indices: Tensor<Int64>,
   _ values: Tensor<T>,
@@ -29543,7 +29518,7 @@ public static func sparseSlice<T: TensorFlowScalar>(
 ///   - output_indices: 2-D.  The `indices` of the sliced `SparseTensor`.
 ///
 /// - Output val_grad: 1-D. The gradient with respect to the non-empty values of input `SparseTensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSliceGrad<T: Numeric & TensorFlowScalar>(
   backpropValGrad: Tensor<T>,
   inputIndices: Tensor<Int64>,
@@ -29584,7 +29559,7 @@ public static func sparseSliceGrad<T: Numeric & TensorFlowScalar>(
 ///   - sp_shape: 1-D.  Shape of the input SparseTensor.
 ///
 /// - Output output: 1-D.  The `NNZ` values for the result `SparseTensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSoftmax<T: FloatingPoint & TensorFlowScalar>(
   spIndices: Tensor<Int64>,
   spValues: Tensor<T>,
@@ -29615,7 +29590,7 @@ public static func sparseSoftmax<T: FloatingPoint & TensorFlowScalar>(
 /// - Outputs:
 ///   - loss: Per example loss (batch_size vector).
 ///   - backprop: backpropagated gradients (batch_size x num_classes matrix).
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSoftmaxCrossEntropyWithLogits<
     T: FloatingPoint & TensorFlowScalar,
     Tlabels: BinaryInteger & TensorFlowScalar
@@ -29647,7 +29622,7 @@ public static func sparseSoftmaxCrossEntropyWithLogits<
 /// - Outputs:
 ///   - output_indices: 2-D.  The indices of the output SparseTensor.
 ///   - output_values: 1-D.  The values of the output SparseTensor.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSparseMaximum<T: Numeric & TensorFlowScalar>(
   aIndices: Tensor<Int64>,
   aValues: Tensor<T>,
@@ -29683,7 +29658,7 @@ public static func sparseSparseMaximum<T: Numeric & TensorFlowScalar>(
 /// - Outputs:
 ///   - output_indices: 2-D.  The indices of the output SparseTensor.
 ///   - output_values: 1-D.  The values of the output SparseTensor.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSparseMinimum<T: Numeric & TensorFlowScalar>(
   aIndices: Tensor<Int64>,
   aValues: Tensor<T>,
@@ -29739,7 +29714,7 @@ public static func sparseSparseMinimum<T: Numeric & TensorFlowScalar>(
 ///     tensors.
 ///   - output_shape: A list of 1-D tensors represents the shape of the output sparse
 ///     tensors.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseSplit<T: TensorFlowScalar>(
   splitDim: Tensor<Int64>,
   indices: Tensor<Int64>,
@@ -29766,7 +29741,7 @@ public static func sparseSplit<T: TensorFlowScalar>(
 ///   - a_values: 1-D.  The `values` of the `SparseTensor`, with shape `[nnz]`.
 ///   - a_shape: 1-D.  The `shape` of the `SparseTensor`, with shape `[ndims]`.
 ///   - b: `ndims`-D Tensor.  With shape `a_shape`.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseTensorDenseAdd<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -29809,7 +29784,7 @@ public static func sparseTensorDenseAdd<
 ///     is transpose(conj(A)).  Otherwise it's transpose(A).
 ///   - adjoint_b: Use the adjoint of B in the matrix multiply.  If B is complex, this
 ///     is transpose(conj(B)).  Otherwise it's transpose(B).
-@inlinable @inline(__always)
+@inlinable
 public static func sparseTensorDenseMatMul<
     T: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -29834,7 +29809,7 @@ public static func sparseTensorDenseMatMul<
 }
 
 /// Creates a dataset that splits a SparseTensor into elements row-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseTensorSliceDataset<Tvalues: TensorFlowScalar>(
   indices: Tensor<Int64>,
   _ values: Tensor<Tvalues>,
@@ -29883,7 +29858,7 @@ public static func sparseTensorSliceDataset<Tvalues: TensorFlowScalar>(
 ///   lexicographic order and that there are no repeats.
 ///
 /// - Output dense: Dense output tensor of shape `output_shape`.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseToDense<
     T: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -29953,7 +29928,7 @@ public static func sparseToDense<
 ///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
 ///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
 ///     is the max result set size across all `0...n-1` dimensions.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseToSparseSetOperation<T: BinaryInteger & TensorFlowScalar>(
   set1Indices: Tensor<Int64>,
   set1Values: Tensor<T>,
@@ -30025,7 +30000,7 @@ public static func sparseToSparseSetOperation<T: BinaryInteger & TensorFlowScala
 ///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
 ///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
 ///     is the max result set size across all `0...n-1` dimensions.
-@inlinable @inline(__always)
+@inlinable
 public static func sparseToSparseSetOperation(
   set1Indices: Tensor<Int64>,
   set1Values: StringTensor,
@@ -30062,7 +30037,7 @@ public static func sparseToSparseSetOperation(
 /// - Output output: They are identically shaped tensors, whose shape matches that of `value`
 ///   except along `axis`, where their sizes are
 ///   `values.shape[split_dim] / num_split`.
-@inlinable @inline(__always)
+@inlinable
 public static func split<T: TensorFlowScalar>(
   splitDim: Tensor<Int32>,
   value: Tensor<T>,
@@ -30089,7 +30064,7 @@ public static func split<T: TensorFlowScalar>(
 /// - Output output: Tensors whose shape matches that of `value`
 ///   except along `axis`, where their sizes are
 ///   `size_splits[i]`.
-@inlinable @inline(__always)
+@inlinable
 public static func splitV<
     T: TensorFlowScalar,
     Tlen: BinaryInteger & TensorFlowScalar
@@ -30112,7 +30087,7 @@ public static func splitV<
 /// Computes square root of x element-wise.
 ///
 /// I.e., \\(y = \sqrt{x} = x^{1/2}\\).
-@inlinable @inline(__always)
+@inlinable
 public static func sqrt<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -30126,7 +30101,7 @@ public static func sqrt<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// Specifically, `grad = dy * 0.5 / y`, where `y = sqrt(x)`, and `dy`
 /// is the corresponding input gradient.
-@inlinable @inline(__always)
+@inlinable
 public static func sqrtGrad<T: FloatingPoint & TensorFlowScalar>(
   _ y: Tensor<T>,
   dy: Tensor<T>
@@ -30141,7 +30116,7 @@ public static func sqrtGrad<T: FloatingPoint & TensorFlowScalar>(
 /// Computes square of x element-wise.
 ///
 /// I.e., \\(y = x * x = x^2\\).
-@inlinable @inline(__always)
+@inlinable
 public static func square<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -30155,7 +30130,7 @@ public static func square<T: Numeric & TensorFlowScalar>(
 ///
 /// *NOTE*: `SquaredDifference` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func squaredDifference<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -30196,7 +30171,7 @@ public static func squaredDifference<T: Numeric & TensorFlowScalar>(
 ///
 /// - Output output: Contains the same data as `input`, but has one or more dimensions of
 ///   size 1 removed.
-@inlinable @inline(__always)
+@inlinable
 public static func squeeze<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   squeezeDims: [Int32]
@@ -30211,7 +30186,7 @@ public static func squeeze<T: TensorFlowScalar>(
 /// Delete the stack from its resource container.
 ///
 /// - Parameter handle: The handle to a stack.
-@inlinable @inline(__always)
+@inlinable
 public static func stackCloseV2(
   handle: ResourceHandle
 ) {
@@ -30227,7 +30202,7 @@ public static func stackCloseV2(
 /// - Attr elem_type: The type of the elem that is popped.
 ///
 /// - Output elem: The tensor that is popped from the top of the stack.
-@inlinable @inline(__always)
+@inlinable
 public static func stackPopV2<ElemType: TensorFlowScalar>(
   handle: ResourceHandle
 ) -> Tensor<ElemType> {
@@ -30246,7 +30221,7 @@ public static func stackPopV2<ElemType: TensorFlowScalar>(
 /// - Attr swap_memory: Swap `elem` to CPU. Default to false.
 ///
 /// - Output output: The same tensor as the input 'elem'.
-@inlinable @inline(__always)
+@inlinable
 public static func stackPushV2<T: TensorFlowScalar>(
   handle: ResourceHandle,
   elem: Tensor<T>,
@@ -30271,7 +30246,7 @@ public static func stackPushV2<T: TensorFlowScalar>(
 ///     value is the name of the 'Stack' op (which is guaranteed unique).
 ///
 /// - Output handle: The handle to the stack.
-@inlinable @inline(__always)
+@inlinable
 public static func stackV2(
   maxSize: Tensor<Int32>,
   elemType: TensorDataType,
@@ -30300,7 +30275,7 @@ public static func stackV2(
 ///   - container: If non-empty, this queue is placed in the given container. Otherwise,
 ///     a default container is used.
 ///   - shared_name: It is necessary to match this name to the matching Unstage Op.
-@inlinable @inline(__always)
+@inlinable
 public static func stage<Dtypes: TensorArrayProtocol>(
   _ values: Dtypes,
   capacity: Int64 = 0,
@@ -30319,7 +30294,7 @@ public static func stage<Dtypes: TensorArrayProtocol>(
 }
 
 /// Op removes all elements in the underlying container.
-@inlinable @inline(__always)
+@inlinable
 public static func stageClear(
   capacity: Int64 = 0,
   memoryLimit: Int64 = 0,
@@ -30341,7 +30316,7 @@ public static func stageClear(
 /// underlying container does not contain sufficient elements
 /// this op will block until it does.   This Op is optimized for
 /// performance.
-@inlinable @inline(__always)
+@inlinable
 public static func stagePeek<Dtypes: TensorGroup>(
   index: Tensor<Int32>,
   capacity: Int64 = 0,
@@ -30360,7 +30335,7 @@ public static func stagePeek<Dtypes: TensorGroup>(
 }
 
 /// Op returns the number of elements in the underlying container.
-@inlinable @inline(__always)
+@inlinable
 public static func stageSize(
   capacity: Int64 = 0,
   memoryLimit: Int64 = 0,
@@ -30391,7 +30366,7 @@ public static func stageSize(
 ///           stateful.
 ///
 /// - Output output: A list of return values.
-@inlinable @inline(__always)
+@inlinable
 public static func statefulPartitionedCall<
     Tin: TensorArrayProtocol,
     Tout: TensorGroup,
@@ -30415,7 +30390,7 @@ public static func statefulPartitionedCall<
   return op.execute(Int(Tout._typeList.count))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func statefulRandomBinomial<
     S: BinaryInteger & TensorFlowScalar,
     T: Numeric & TensorFlowScalar,
@@ -30450,7 +30425,7 @@ public static func statefulRandomBinomial<
 /// - Attr dtype: The type of the output.
 ///
 /// - Output output: A tensor of the specified shape filled with random normal values.
-@inlinable @inline(__always)
+@inlinable
 public static func statefulStandardNormal<
     Dtype: TensorFlowScalar,
     ShapeDtype: TensorFlowScalar
@@ -30478,7 +30453,7 @@ public static func statefulStandardNormal<
 /// - Attr dtype: The type of the output.
 ///
 /// - Output output: A tensor of the specified shape filled with random normal values.
-@inlinable @inline(__always)
+@inlinable
 public static func statefulStandardNormalV2<
     Dtype: TensorFlowScalar,
     ShapeDtype: TensorFlowScalar
@@ -30510,7 +30485,7 @@ public static func statefulStandardNormalV2<
 /// - Attr dtype: The type of the output.
 ///
 /// - Output output: Random values with specified shape.
-@inlinable @inline(__always)
+@inlinable
 public static func statefulTruncatedNormal<
     Dtype: TensorFlowScalar,
     ShapeDtype: TensorFlowScalar
@@ -30541,7 +30516,7 @@ public static func statefulTruncatedNormal<
 /// - Attr dtype: The type of the output.
 ///
 /// - Output output: Random values with specified shape.
-@inlinable @inline(__always)
+@inlinable
 public static func statefulUniform<
     Dtype: TensorFlowScalar,
     ShapeDtype: TensorFlowScalar
@@ -30571,7 +30546,7 @@ public static func statefulUniform<
 /// - Attr dtype: The type of the output.
 ///
 /// - Output output: Random values with specified shape.
-@inlinable @inline(__always)
+@inlinable
 public static func statefulUniformFullInt<
     Dtype: TensorFlowScalar,
     ShapeDtype: TensorFlowScalar
@@ -30609,7 +30584,7 @@ public static func statefulUniformFullInt<
 /// - Attr dtype: The type of the output.
 ///
 /// - Output output: Random values with specified shape.
-@inlinable @inline(__always)
+@inlinable
 public static func statefulUniformInt<
     Dtype: TensorFlowScalar,
     ShapeDtype: TensorFlowScalar
@@ -30654,7 +30629,7 @@ public static func statefulUniformInt<
 ///         types are the same as what then_branch returns.
 ///
 /// - Output output: A list of return values.
-@inlinable @inline(__always)
+@inlinable
 public static func statelessIf<
     Tcond: TensorFlowScalar,
     Tin: TensorArrayProtocol,
@@ -30690,7 +30665,7 @@ public static func statelessIf<
 ///
 /// - Output output: 2-D Tensor with shape `[batch_size, num_samples]`.  Each slice `[i, :]`
 ///   contains the drawn class labels with range `[0, num_classes)`.
-@inlinable @inline(__always)
+@inlinable
 public static func statelessMultinomial<
     T: Numeric & TensorFlowScalar,
     Tseed: BinaryInteger & TensorFlowScalar,
@@ -30723,7 +30698,7 @@ public static func statelessMultinomial<
 /// - Attr dtype: The type of the output.
 ///
 /// - Output output: Random values with specified shape.
-@inlinable @inline(__always)
+@inlinable
 public static func statelessRandomNormal<
     Dtype: FloatingPoint & TensorFlowScalar,
     T: BinaryInteger & TensorFlowScalar,
@@ -30755,7 +30730,7 @@ public static func statelessRandomNormal<
 /// - Attr dtype: The type of the output.
 ///
 /// - Output output: Random values with specified shape.
-@inlinable @inline(__always)
+@inlinable
 public static func statelessRandomUniform<
     Dtype: FloatingPoint & TensorFlowScalar,
     T: BinaryInteger & TensorFlowScalar,
@@ -30788,7 +30763,7 @@ public static func statelessRandomUniform<
 /// - Attr dtype: The type of the output.
 ///
 /// - Output output: Random values with specified shape.
-@inlinable @inline(__always)
+@inlinable
 public static func statelessRandomUniformInt<
     Dtype: BinaryInteger & TensorFlowScalar,
     T: BinaryInteger & TensorFlowScalar,
@@ -30825,7 +30800,7 @@ public static func statelessRandomUniformInt<
 /// - Attr dtype: The type of the output.
 ///
 /// - Output output: Random values with specified shape.
-@inlinable @inline(__always)
+@inlinable
 public static func statelessTruncatedNormal<
     Dtype: FloatingPoint & TensorFlowScalar,
     T: BinaryInteger & TensorFlowScalar,
@@ -30864,7 +30839,7 @@ public static func statelessTruncatedNormal<
 ///           by T.
 ///
 /// - Output output: A list of output tensors whose types are T.
-@inlinable @inline(__always)
+@inlinable
 public static func statelessWhile<
     T: TensorArrayProtocol,
     CondIn: TensorGroup,
@@ -30898,7 +30873,7 @@ public static func statelessWhile<
 /// - Attr pattern: The regular expression to match the input.
 ///
 /// - Output output: A bool tensor with the same shape as `input`.
-@inlinable @inline(__always)
+@inlinable
 public static func staticRegexFullMatch(
   _ input: StringTensor,
   pattern: String
@@ -30922,7 +30897,7 @@ public static func staticRegexFullMatch(
 ///     is done only on the first match.
 ///
 /// - Output output: The text after applying pattern and rewrite.
-@inlinable @inline(__always)
+@inlinable
 public static func staticRegexReplace(
   _ input: StringTensor,
   pattern: String,
@@ -30937,7 +30912,7 @@ public static func staticRegexReplace(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func statsAggregatorHandleV2(
   container: String,
   sharedName: String
@@ -30949,7 +30924,7 @@ public static func statsAggregatorHandleV2(
 }
 
 /// Set a summary_writer_interface to record statistics using given stats_aggregator.
-@inlinable @inline(__always)
+@inlinable
 public static func statsAggregatorSetSummaryWriter(
   statsAggregator: ResourceHandle,
   summary: ResourceHandle
@@ -30981,7 +30956,7 @@ public static func statsAggregatorSetSummaryWriter(
 ///    through the graph that generated the samples from the model.
 /// *  Adversarial training, where no backprop should happen through the adversarial
 ///    example generation process.
-@inlinable @inline(__always)
+@inlinable
 public static func stopGradient<T: TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<T> {
@@ -31118,7 +31093,7 @@ public static func stopGradient<T: TensorFlowScalar>(
 ///     must imply a slice of size 1 in the dimension. For example in
 ///     python one might do `foo[:, 3, :]` which would result in
 ///     `shrink_axis_mask` being 2.
-@inlinable @inline(__always)
+@inlinable
 public static func stridedSlice<
     T: TensorFlowScalar,
     Index: BinaryInteger & TensorFlowScalar
@@ -31158,7 +31133,7 @@ public static func stridedSlice<
 /// Arguments are the same as StridedSliceGrad with the exception that
 /// `dy` is the input gradient to be propagated and `shape` is the
 /// shape of `StridedSlice`'s `input`.
-@inlinable @inline(__always)
+@inlinable
 public static func stridedSliceGrad<
     T: TensorFlowScalar,
     Index: BinaryInteger & TensorFlowScalar
@@ -31202,7 +31177,7 @@ public static func stridedSliceGrad<
 ///   - summarize: When formatting the tensor summaries print the first and last summarize entries of each tensor dimension.
 ///
 /// - Output output: = The resulting string scalar.
-@inlinable @inline(__always)
+@inlinable
 public static func stringFormat<T: TensorArrayProtocol>(
   inputs: T,
   template: String = "%s",
@@ -31227,7 +31202,7 @@ public static func stringFormat<T: TensorArrayProtocol>(
 ///   of non-scalar inputs.
 ///
 /// - Attr separator: string, an optional join separator.
-@inlinable @inline(__always)
+@inlinable
 public static func stringJoin(
   inputs: [StringTensor],
   separator: String
@@ -31253,7 +31228,7 @@ public static func stringJoin(
 ///
 /// - Output output: Integer tensor that has the same shape as `input`. The output contains the
 ///   element-wise string lengths of `input`.
-@inlinable @inline(__always)
+@inlinable
 public static func stringLength(
   _ input: StringTensor,
   unit: Unit = .byte
@@ -31264,7 +31239,7 @@ public static func stringLength(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func stringListAttr(
   _ a: [String],
   _ b: String
@@ -31310,7 +31285,7 @@ public static func stringListAttr(
 ///   - shape: a length-2 vector of int64 representing the shape of the sparse
 ///     tensor, where the first value is N and the second value is the maximum number
 ///     of tokens in a single input entry.
-@inlinable @inline(__always)
+@inlinable
 public static func stringSplit(
   _ input: StringTensor,
   delimiter: StringTensor,
@@ -31355,7 +31330,7 @@ public static func stringSplit(
 ///   - sep: `0-D` string `Tensor`, the delimiter character.
 ///
 /// - Attr maxsplit: An `int`. If `maxsplit > 0`, limit of the split of the result.
-@inlinable @inline(__always)
+@inlinable
 public static func stringSplitV2(
   _ input: StringTensor,
   sep: StringTensor,
@@ -31373,7 +31348,7 @@ public static func stringSplitV2(
 /// - Parameter input: A string `Tensor` of any shape.
 ///
 /// - Output output: A string `Tensor` of the same shape as the input.
-@inlinable @inline(__always)
+@inlinable
 public static func stringStrip(
   _ input: StringTensor
 ) -> StringTensor {
@@ -31394,7 +31369,7 @@ public static func stringStrip(
 /// - Attr num_buckets: The number of buckets.
 ///
 /// - Output output: A Tensor of the same shape as the input `string_tensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func stringToHashBucket(
   stringTensor: StringTensor,
   numBuckets: Int64
@@ -31419,7 +31394,7 @@ public static func stringToHashBucket(
 /// - Attr num_buckets: The number of buckets.
 ///
 /// - Output output: A Tensor of the same shape as the input `string_tensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func stringToHashBucketFast(
   _ input: StringTensor,
   numBuckets: Int64
@@ -31451,7 +31426,7 @@ public static func stringToHashBucketFast(
 ///     elements.
 ///
 /// - Output output: A Tensor of the same shape as the input `string_tensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func stringToHashBucketStrong(
   _ input: StringTensor,
   numBuckets: Int64,
@@ -31472,7 +31447,7 @@ public static func stringToHashBucketStrong(
 /// - Attr out_type: The numeric type to interpret each string in `string_tensor` as.
 ///
 /// - Output output: A Tensor of the same shape as the input `string_tensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func stringToNumber<OutType: Numeric & TensorFlowScalar>(
   stringTensor: StringTensor
 ) -> Tensor<OutType> {
@@ -31482,7 +31457,7 @@ public static func stringToNumber<OutType: Numeric & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func stubResourceHandleOp(
   container: String,
   sharedName: String
@@ -31497,7 +31472,7 @@ public static func stubResourceHandleOp(
 ///
 /// *NOTE*: `Subtract` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func sub<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -31599,7 +31574,7 @@ public static func sub<T: Numeric & TensorFlowScalar>(
 ///   UTF-8.
 ///
 /// - Output output: Tensor of substrings
-@inlinable @inline(__always)
+@inlinable
 public static func substr<T: BinaryInteger & TensorFlowScalar>(
   _ input: StringTensor,
   pos: Tensor<T>,
@@ -31630,7 +31605,7 @@ public static func substr<T: BinaryInteger & TensorFlowScalar>(
 /// - Attr keep_dims: If true, retain reduced dimensions with length 1.
 ///
 /// - Output output: The reduced tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func sum<
     T: Numeric & TensorFlowScalar,
     Tidx: BinaryInteger & TensorFlowScalar
@@ -31648,7 +31623,7 @@ public static func sum<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func summaryWriter(
   sharedName: String,
   container: String
@@ -31692,7 +31667,7 @@ public static func summaryWriter(
 ///   - v: Left singular vectors. If `full_matrices` is `False` then shape is
 ///     `[..., N, P]`. If `full_matrices` is `True` then shape is `[..., N, N]`.
 ///     Undefined if `compute_uv` is false.
-@inlinable @inline(__always)
+@inlinable
 public static func svd<T: FloatingPoint & TensorFlowScalar>(
   _ input: Tensor<T>,
   computeUv: Bool = true,
@@ -31720,7 +31695,7 @@ public static func svd<T: FloatingPoint & TensorFlowScalar>(
 /// - Outputs:
 ///   - output_false: If `pred` is false, data will be forwarded to this output.
 ///   - output_true: If `pred` is true, data will be forwarded to this output.
-@inlinable @inline(__always)
+@inlinable
 public static func switch_<T: TensorFlowScalar>(
   data: Tensor<T>,
   pred: Tensor<Bool>
@@ -31759,7 +31734,7 @@ public static func switch_<T: TensorFlowScalar>(
 ///     (Needs some math expert to say the comment above better.)
 ///
 /// - Output output: a list of output tensors of size N;
-@inlinable @inline(__always)
+@inlinable
 public static func symbolicGradient<
     Tin: TensorArrayProtocol,
     Tout: TensorGroup,
@@ -31786,7 +31761,7 @@ public static func symbolicGradient<
 ///     compression), (ii) "ZLIB", or (iii) "GZIP".
 ///   - buffer_size: A scalar representing the number of bytes to buffer. A value of
 ///     0 means no buffering will be performed.
-@inlinable @inline(__always)
+@inlinable
 public static func tFRecordDataset(
   filenames: StringTensor,
   compressionType: StringTensor,
@@ -31808,7 +31783,7 @@ public static func tFRecordDataset(
 ///     with this shared_name. Otherwise, the node name is used instead.
 ///
 /// - Output reader_handle: The handle to reference the Reader.
-@inlinable @inline(__always)
+@inlinable
 public static func tFRecordReaderV2(
   container: String,
   sharedName: String,
@@ -31822,7 +31797,7 @@ public static func tFRecordReaderV2(
 }
 
 /// CompilationResultProto indicating the status of the TPU compilation.
-@inlinable @inline(__always)
+@inlinable
 public static func tPUCompilationResult(
 ) -> StringTensor {
   let op = TFE_Op("TPUCompilationResult")
@@ -31847,7 +31822,7 @@ public static func tPUCompilationResult(
 ///     these activations were computed.
 ///   - lookup_id: Identifier of the set of embedding indices which produced these
 ///     activations.
-@inlinable @inline(__always)
+@inlinable
 public static func tPUEmbeddingActivations(
   embeddingVariable: Tensor<Float>,
   slicedActivations: Tensor<Float>,
@@ -31869,7 +31844,7 @@ public static func tPUEmbeddingActivations(
 /// consumed by TPUPartitionedCall.
 ///
 /// - Output device_ordinals: A vector 1 or more TPU cores.
-@inlinable @inline(__always)
+@inlinable
 public static func tPUOrdinalSelector(
 ) -> Tensor<Int32> {
   let op = TFE_Op("TPUOrdinalSelector")
@@ -31889,7 +31864,7 @@ public static func tPUOrdinalSelector(
 ///   - f: The function to call.
 ///
 /// - Output output: The output of the function call.
-@inlinable @inline(__always)
+@inlinable
 public static func tPUPartitionedCall<
     Tin: TensorArrayProtocol,
     Tout: TensorGroup,
@@ -31940,7 +31915,7 @@ public static func tPUPartitionedCall<
 ///   - output_types: the types of the outputs of 'computation'.
 ///
 /// - Output outputs: the outputs of 'computation'.
-@inlinable @inline(__always)
+@inlinable
 public static func tPUReplicate<
     ComputationIn: TensorGroup,
     ComputationOut: TensorGroup,
@@ -31994,7 +31969,7 @@ public static func tPUReplicate<
 ///   - use_tpu: Whether to place the computation on the TPU.
 ///   - device_assignment: The assignment of devices for the computation.
 ///   - computation_shape: DEPRECATED. Use num_cores_per_replica instead.
-@inlinable @inline(__always)
+@inlinable
 public static func tPUReplicateMetadata(
   numReplicas: Int64,
   numCoresPerReplica: Int64 = 1,
@@ -32020,7 +31995,7 @@ public static func tPUReplicateMetadata(
 }
 
 /// Connects N inputs to an N-way replicated TPU computation.
-@inlinable @inline(__always)
+@inlinable
 public static func tPUReplicatedInput<T: TensorFlowScalar>(
   inputs: [Tensor<T>]
 ) -> Tensor<T> {
@@ -32032,7 +32007,7 @@ public static func tPUReplicatedInput<T: TensorFlowScalar>(
 }
 
 /// Connects outputs of an N-way replicated computation to N outputs.
-@inlinable @inline(__always)
+@inlinable
 public static func tPUReplicatedOutput<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   numReplicas: Int64
@@ -32049,7 +32024,7 @@ public static func tPUReplicatedOutput<T: TensorFlowScalar>(
 /// - Parameter count: A scalar representing the number of elements from the `input_dataset`
 ///   that should be taken. A value of `-1` indicates that all of `input_dataset`
 ///   is taken.
-@inlinable @inline(__always)
+@inlinable
 public static func takeDataset(
   inputDataset: VariantHandle,
   count: Tensor<Int64>,
@@ -32130,7 +32105,7 @@ public static func takeDataset(
 ///   - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
 ///   - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
 ///   - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
-@inlinable @inline(__always)
+@inlinable
 public static func takeManySparseFromTensorsMap<Dtype: TensorFlowScalar>(
   sparseHandles: Tensor<Int64>,
   container: String,
@@ -32145,7 +32120,7 @@ public static func takeManySparseFromTensorsMap<Dtype: TensorFlowScalar>(
 }
 
 /// Computes tan of x element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func tan<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -32156,7 +32131,7 @@ public static func tan<T: Numeric & TensorFlowScalar>(
 }
 
 /// Computes hyperbolic tangent of `x` element-wise.
-@inlinable @inline(__always)
+@inlinable
 public static func tanh<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -32170,7 +32145,7 @@ public static func tanh<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// Specifically, `grad = dy * (1 - y*y)`, where `y = tanh(x)`, and `dy`
 /// is the corresponding input gradient.
-@inlinable @inline(__always)
+@inlinable
 public static func tanhGrad<T: FloatingPoint & TensorFlowScalar>(
   _ y: Tensor<T>,
   dy: Tensor<T>
@@ -32183,7 +32158,7 @@ public static func tanhGrad<T: FloatingPoint & TensorFlowScalar>(
 }
 
 /// Deprecated. Use TensorArrayCloseV3
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayCloseV2(
   handle: StringTensor
 ) {
@@ -32198,7 +32173,7 @@ public static func tensorArrayCloseV2(
 /// of a step/run.
 ///
 /// - Parameter handle: The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayCloseV3(
   handle: ResourceHandle
 ) {
@@ -32208,7 +32183,7 @@ public static func tensorArrayCloseV3(
 }
 
 /// Deprecated. Use TensorArrayConcatV3
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayConcatV2<Dtype: TensorFlowScalar>(
   handle: StringTensor,
   flowIn: Tensor<Float>,
@@ -32253,7 +32228,7 @@ public static func tensorArrayConcatV2<Dtype: TensorFlowScalar>(
 ///   - lengths: A vector of the row sizes of the original T elements in the
 ///     value output.  In the example above, this would be the values:
 ///     `(n1, n2, ..., n(T-1))`.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayConcatV3<Dtype: TensorFlowScalar>(
   handle: ResourceHandle,
   flowIn: Tensor<Float>,
@@ -32268,7 +32243,7 @@ public static func tensorArrayConcatV3<Dtype: TensorFlowScalar>(
 }
 
 /// Deprecated. Use TensorArrayGatherV3
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayGatherV2<Dtype: TensorFlowScalar>(
   handle: StringTensor,
   indices: Tensor<Int32>,
@@ -32301,7 +32276,7 @@ public static func tensorArrayGatherV2<Dtype: TensorFlowScalar>(
 ///
 /// - Output value: All of the elements in the TensorArray, concatenated along a new
 ///   axis (the new dimension 0).
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayGatherV3<Dtype: TensorFlowScalar>(
   handle: ResourceHandle,
   indices: Tensor<Int32>,
@@ -32318,7 +32293,7 @@ public static func tensorArrayGatherV3<Dtype: TensorFlowScalar>(
 }
 
 /// Deprecated. Use TensorArrayGradV3
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayGradV2(
   handle: StringTensor,
   flowIn: Tensor<Float>,
@@ -32376,7 +32351,7 @@ public static func tensorArrayGradV2(
 ///
 /// - Attr source: The gradient source string, used to decide which gradient TensorArray
 ///   to return.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayGradV3(
   handle: ResourceHandle,
   flowIn: Tensor<Float>,
@@ -32405,7 +32380,7 @@ public static func tensorArrayGradV3(
 ///
 /// - Attr source: The gradient source string, used to decide which gradient TensorArray
 ///   to return.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayGradWithShape(
   handle: ResourceHandle,
   flowIn: Tensor<Float>,
@@ -32421,7 +32396,7 @@ public static func tensorArrayGradWithShape(
 }
 
 /// Deprecated. Use TensorArrayReadV3
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayReadV2<Dtype: TensorFlowScalar>(
   handle: StringTensor,
   index: Tensor<Int32>,
@@ -32444,7 +32419,7 @@ public static func tensorArrayReadV2<Dtype: TensorFlowScalar>(
 /// - Attr dtype: The type of the elem that is returned.
 ///
 /// - Output value: The tensor that is read from the TensorArray.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayReadV3<Dtype: TensorFlowScalar>(
   handle: ResourceHandle,
   index: Tensor<Int32>,
@@ -32459,7 +32434,7 @@ public static func tensorArrayReadV3<Dtype: TensorFlowScalar>(
 }
 
 /// Deprecated. Use TensorArrayScatterV3
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayScatterV2<T: TensorFlowScalar>(
   handle: StringTensor,
   indices: Tensor<Int32>,
@@ -32486,7 +32461,7 @@ public static func tensorArrayScatterV2<T: TensorFlowScalar>(
 ///   - flow_in: A float scalar that enforces proper chaining of operations.
 ///
 /// - Output flow_out: A float scalar that enforces proper chaining of operations.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayScatterV3<T: TensorFlowScalar>(
   handle: ResourceHandle,
   indices: Tensor<Int32>,
@@ -32503,7 +32478,7 @@ public static func tensorArrayScatterV3<T: TensorFlowScalar>(
 }
 
 /// Deprecated. Use TensorArraySizeV3
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArraySizeV2(
   handle: StringTensor,
   flowIn: Tensor<Float>
@@ -32521,7 +32496,7 @@ public static func tensorArraySizeV2(
 ///   - flow_in: A float scalar that enforces proper chaining of operations.
 ///
 /// - Output size: The current size of the TensorArray.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArraySizeV3(
   handle: ResourceHandle,
   flowIn: Tensor<Float>
@@ -32533,7 +32508,7 @@ public static func tensorArraySizeV3(
 }
 
 /// Deprecated. Use TensorArraySplitV3
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArraySplitV2<T: TensorFlowScalar>(
   handle: StringTensor,
   value: Tensor<T>,
@@ -32577,7 +32552,7 @@ public static func tensorArraySplitV2<T: TensorFlowScalar>(
 ///   - flow_in: A float scalar that enforces proper chaining of operations.
 ///
 /// - Output flow_out: A float scalar that enforces proper chaining of operations.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArraySplitV3<T: TensorFlowScalar>(
   handle: ResourceHandle,
   value: Tensor<T>,
@@ -32594,7 +32569,7 @@ public static func tensorArraySplitV3<T: TensorFlowScalar>(
 }
 
 /// Deprecated. Use TensorArrayV3
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayV2(
   size: Tensor<Int32>,
   dtype: TensorDataType,
@@ -32642,7 +32617,7 @@ public static func tensorArrayV2(
 /// - Outputs:
 ///   - handle: The handle to the TensorArray.
 ///   - flow: A scalar used to control gradient flow.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayV3(
   size: Tensor<Int32>,
   dtype: TensorDataType,
@@ -32664,7 +32639,7 @@ public static func tensorArrayV3(
 }
 
 /// Deprecated. Use TensorArrayGradV3
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayWriteV2<T: TensorFlowScalar>(
   handle: StringTensor,
   index: Tensor<Int32>,
@@ -32689,7 +32664,7 @@ public static func tensorArrayWriteV2<T: TensorFlowScalar>(
 ///   - flow_in: A float scalar that enforces proper chaining of operations.
 ///
 /// - Output flow_out: A float scalar that enforces proper chaining of operations.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorArrayWriteV3<T: TensorFlowScalar>(
   handle: ResourceHandle,
   index: Tensor<Int32>,
@@ -32706,7 +32681,7 @@ public static func tensorArrayWriteV3<T: TensorFlowScalar>(
 }
 
 /// Creates a dataset that emits `components` as a tuple of tensors once.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorDataset<ToutputTypes: TensorArrayProtocol>(
   components: ToutputTypes,
   outputShapes: [TensorShape?]
@@ -32723,7 +32698,7 @@ public static func tensorDataset<ToutputTypes: TensorArrayProtocol>(
 /// - Parameters:
 ///   - tree_handle: Handle to the tree resource to be created.
 ///   - tree_config: Serialized proto string of the boosted_trees.Tree.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorForestCreateTreeVariable(
   treeHandle: ResourceHandle,
   treeConfig: StringTensor
@@ -32739,7 +32714,7 @@ public static func tensorForestCreateTreeVariable(
 /// - Parameters:
 ///   - tree_handle: Handle to the tree resource to be restored.
 ///   - tree_config: Serialied proto string of the boosted_trees.Tree proto.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorForestTreeDeserialize(
   treeHandle: ResourceHandle,
   treeConfig: StringTensor
@@ -32755,7 +32730,7 @@ public static func tensorForestTreeDeserialize(
 /// - Parameter tree_handle: Handle to the tree.
 ///
 /// - Output is_initialized: Whether the tree is initialized.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorForestTreeIsInitializedOp(
   treeHandle: ResourceHandle
 ) -> Tensor<Bool> {
@@ -32773,7 +32748,7 @@ public static func tensorForestTreeIsInitializedOp(
 /// - Attr logits_dimension: Scalar, dimension of the logits.
 ///
 /// - Output logits: The logits predictions from the tree for each instance in the batch.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorForestTreePredict(
   treeHandle: ResourceHandle,
   denseFeatures: Tensor<Float>,
@@ -32787,7 +32762,7 @@ public static func tensorForestTreePredict(
 }
 
 /// Creates a handle to a TensorForestTreeResource
-@inlinable @inline(__always)
+@inlinable
 public static func tensorForestTreeResourceHandleOp(
   container: String,
   sharedName: String
@@ -32803,7 +32778,7 @@ public static func tensorForestTreeResourceHandleOp(
 /// - Parameter tree_handle: Handle to the tree resource to be serialized.
 ///
 /// - Output tree_config: Serialied proto string of the tree resource.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorForestTreeSerialize(
   treeHandle: ResourceHandle
 ) -> StringTensor {
@@ -32817,7 +32792,7 @@ public static func tensorForestTreeSerialize(
 /// - Parameter tree_handle: Handle to the tree resource.
 ///
 /// - Output tree_size: The size of the tree.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorForestTreeSize(
   treeHandle: ResourceHandle
 ) -> Tensor<Int32> {
@@ -32834,7 +32809,7 @@ public static func tensorForestTreeSize(
 /// tensor: The concated result.
 /// lengths: Output tensor containing sizes of the 0th dimension of tensors in the list, used for computing the gradient.
 ///
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListConcat<ElementDtype: TensorFlowScalar>(
   inputHandle: VariantHandle,
   elementShape: TensorShape?
@@ -32846,7 +32821,7 @@ public static func tensorListConcat<ElementDtype: TensorFlowScalar>(
   return op.execute(Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListConcatLists(
   inputA: VariantHandle,
   inputB: VariantHandle,
@@ -32873,7 +32848,7 @@ public static func tensorListConcatLists(
 /// tensor: The concated result.
 /// lengths: Output tensor containing sizes of the 0th dimension of tensors in the list, used for computing the gradient.
 ///
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListConcatV2<
     ElementDtype: TensorFlowScalar,
     ShapeType: BinaryInteger & TensorFlowScalar
@@ -32895,7 +32870,7 @@ public static func tensorListConcatV2<
 ///
 ///   input_handle: the list
 ///   element_shape: the shape of elements of the list
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListElementShape<ShapeType: BinaryInteger & TensorFlowScalar>(
   inputHandle: VariantHandle
 ) -> Tensor<ShapeType> {
@@ -32911,7 +32886,7 @@ public static func tensorListElementShape<ShapeType: BinaryInteger & TensorFlowS
 ///
 /// tensor: The input tensor.
 /// output_handle: The list.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListFromTensor<
     ElementDtype: TensorFlowScalar,
     ShapeType: BinaryInteger & TensorFlowScalar
@@ -32935,7 +32910,7 @@ public static func tensorListFromTensor<
 /// input_handle: The input tensor list.
 /// indices: The indices used to index into the list.
 /// values: The tensor.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListGather<ElementDtype: TensorFlowScalar>(
   inputHandle: VariantHandle,
   indices: Tensor<Int32>,
@@ -32949,7 +32924,7 @@ public static func tensorListGather<ElementDtype: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListGetItem<ElementDtype: TensorFlowScalar>(
   inputHandle: VariantHandle,
   index: Tensor<Int32>,
@@ -32967,7 +32942,7 @@ public static func tensorListGetItem<ElementDtype: TensorFlowScalar>(
 ///
 /// input_handle: the input list
 /// length: the number of tensors in the list
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListLength(
   inputHandle: VariantHandle
 ) -> Tensor<Int32> {
@@ -32984,7 +32959,7 @@ public static func tensorListLength(
 /// tensor: the withdrawn last element of the list
 /// element_dtype: the type of elements in the list
 /// element_shape: the shape of the output tensor
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListPopBack<ElementDtype: TensorFlowScalar>(
   inputHandle: VariantHandle,
   elementShape: Tensor<Int32>
@@ -33003,7 +32978,7 @@ public static func tensorListPopBack<ElementDtype: TensorFlowScalar>(
 /// output_handle: A list with the elements of the old list followed by tensor.
 /// element_dtype: the type of elements in the list.
 /// element_shape: a shape compatible with that of elements in the list.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListPushBack<ElementDtype: TensorFlowScalar>(
   inputHandle: VariantHandle,
   _ tensor: Tensor<ElementDtype>
@@ -33015,7 +32990,7 @@ public static func tensorListPushBack<ElementDtype: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListPushBackBatch<ElementDtype: TensorFlowScalar>(
   inputHandles: VariantHandle,
   _ tensor: Tensor<ElementDtype>
@@ -33033,7 +33008,7 @@ public static func tensorListPushBackBatch<ElementDtype: TensorFlowScalar>(
 /// num_elements: the number of elements to reserve
 /// handle: the output list
 /// element_dtype: the desired type of elements in the list.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListReserve<ShapeType: BinaryInteger & TensorFlowScalar>(
   elementShape: Tensor<ShapeType>,
   numElements: Tensor<Int32>,
@@ -33053,7 +33028,7 @@ public static func tensorListReserve<ShapeType: BinaryInteger & TensorFlowScalar
 /// input_handle: the input list
 /// size: size of the output list
 ///
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListResize(
   inputHandle: VariantHandle,
   size: Tensor<Int32>
@@ -33074,7 +33049,7 @@ public static func tensorListResize(
 /// element_shape: The shape of the elements in the list (can be less specified than
 ///   the shape of the tensor).  
 /// output_handle: The TensorList.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListScatter<
     ElementDtype: TensorFlowScalar,
     ShapeType: BinaryInteger & TensorFlowScalar
@@ -33101,7 +33076,7 @@ public static func tensorListScatter<
 /// tensor: The input tensor.
 /// indices: The indices used to index into the list.
 /// output_handle: The TensorList.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListScatterIntoExistingList<ElementDtype: TensorFlowScalar>(
   inputHandle: VariantHandle,
   _ tensor: Tensor<ElementDtype>,
@@ -33128,7 +33103,7 @@ public static func tensorListScatterIntoExistingList<ElementDtype: TensorFlowSca
 ///   the largest index in indices. If -1, the list is just large enough to include
 ///   the largest index in indices.
 /// output_handle: The TensorList.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListScatterV2<
     ElementDtype: TensorFlowScalar,
     ShapeType: BinaryInteger & TensorFlowScalar
@@ -33148,7 +33123,7 @@ public static func tensorListScatterV2<
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListSetItem<ElementDtype: TensorFlowScalar>(
   inputHandle: VariantHandle,
   index: Tensor<Int32>,
@@ -33171,7 +33146,7 @@ public static func tensorListSetItem<ElementDtype: TensorFlowScalar>(
 /// element_shape: A shape compatible with that of elements in the tensor.
 /// lengths: Vector of sizes of the 0th dimension of tensors in the list.
 /// output_handle: The list.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListSplit<
     ElementDtype: TensorFlowScalar,
     ShapeType: BinaryInteger & TensorFlowScalar
@@ -33197,7 +33172,7 @@ public static func tensorListSplit<
 /// tensor: the gathered result
 /// num_elements: optional. If not -1, the number of elements in the list.
 ///
-@inlinable @inline(__always)
+@inlinable
 public static func tensorListStack<ElementDtype: TensorFlowScalar>(
   inputHandle: VariantHandle,
   elementShape: Tensor<Int32>,
@@ -33284,7 +33259,7 @@ public static func tensorListStack<ElementDtype: TensorFlowScalar>(
 ///   - updates: Updates to scatter into output.
 ///
 /// - Output output: A new tensor copied from tensor and updates added according to the indices.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorScatterAdd<
     T: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -33375,7 +33350,7 @@ public static func tensorScatterAdd<
 ///   - updates: Updates to scatter into output.
 ///
 /// - Output output: A new tensor copied from tensor and updates subtracted according to the indices.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorScatterSub<
     T: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -33478,7 +33453,7 @@ public static func tensorScatterSub<
 ///
 /// - Output output: A new tensor with the given shape and updates applied according
 ///   to the indices.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorScatterUpdate<
     T: TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar
@@ -33497,7 +33472,7 @@ public static func tensorScatterUpdate<
 }
 
 /// Creates a dataset that emits each dim-0 slice of `components` once.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorSliceDataset<ToutputTypes: TensorArrayProtocol>(
   components: ToutputTypes,
   outputShapes: [TensorShape?]
@@ -33517,7 +33492,7 @@ public static func tensorSliceDataset<ToutputTypes: TensorArrayProtocol>(
 ///
 /// NOTE this op currently does not support broadcasting and so `value`'s shape
 /// must be exactly the shape produced by the slice of `input`.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorStridedSliceUpdate<
     T: TensorFlowScalar,
     Index: BinaryInteger & TensorFlowScalar
@@ -33561,7 +33536,7 @@ public static func tensorStridedSliceUpdate<
 ///   - description: A json-encoded SummaryDescription proto.
 ///   - labels: An unused list of strings.
 ///   - display_name: An unused string.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorSummary<T: TensorFlowScalar>(
   _ tensor: Tensor<T>,
   description: String,
@@ -33584,7 +33559,7 @@ public static func tensorSummary<T: TensorFlowScalar>(
 ///   - tensor: A tensor to serialize.
 ///   - serialized_summary_metadata: A serialized SummaryMetadata proto. Contains plugin
 ///     data.
-@inlinable @inline(__always)
+@inlinable
 public static func tensorSummaryV2<T: TensorFlowScalar>(
   tag: StringTensor,
   _ tensor: Tensor<T>,
@@ -33598,7 +33573,7 @@ public static func tensorSummaryV2<T: TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func testAttr<T: FloatingPoint & TensorFlowScalar>(
 ) -> Tensor<T> {
   let op = TFE_Op("TestAttr")
@@ -33606,7 +33581,7 @@ public static func testAttr<T: FloatingPoint & TensorFlowScalar>(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func testStringOutput(
   _ input: Tensor<Float>
 ) -> (output1: Tensor<Float>, output2: StringTensor) {
@@ -33623,7 +33598,7 @@ public static func testStringOutput(
 ///   - compression_type: A scalar containing either (i) the empty string (no
 ///     compression), (ii) "ZLIB", or (iii) "GZIP".
 ///   - buffer_size: A scalar containing the number of bytes to buffer.
-@inlinable @inline(__always)
+@inlinable
 public static func textLineDataset(
   filenames: StringTensor,
   compressionType: StringTensor,
@@ -33646,7 +33621,7 @@ public static func textLineDataset(
 ///     with this shared_name. Otherwise, the node name is used instead.
 ///
 /// - Output reader_handle: The handle to reference the Reader.
-@inlinable @inline(__always)
+@inlinable
 public static func textLineReaderV2(
   skipHeaderLines: Int64 = 0,
   container: String,
@@ -33696,7 +33671,7 @@ public static func textLineReaderV2(
 ///     candidate representing the number of times the candidate is expected
 ///     to occur in a batch of sampled candidates.  If unique=true, then this is a
 ///     probability.
-@inlinable @inline(__always)
+@inlinable
 public static func threadUnsafeUnigramCandidateSampler(
   trueClasses: Tensor<Int64>,
   numTrue: Int64,
@@ -33728,7 +33703,7 @@ public static func threadUnsafeUnigramCandidateSampler(
 /// - Parameters:
 ///   - input: 1-D or higher.
 ///   - multiples: 1-D. Length must be the same as the number of dimensions in `input`
-@inlinable @inline(__always)
+@inlinable
 public static func tile<
     T: TensorFlowScalar,
     Tmultiples: BinaryInteger & TensorFlowScalar
@@ -33749,7 +33724,7 @@ public static func tile<
 /// Since `Tile` takes an input and repeats the input `multiples` times
 /// along each dimension, `TileGrad` takes in `multiples` and aggregates
 /// each repeated tile of `input` into `output`.
-@inlinable @inline(__always)
+@inlinable
 public static func tileGrad<T: TensorFlowScalar>(
   _ input: Tensor<T>,
   multiples: Tensor<Int32>
@@ -33767,7 +33742,7 @@ public static func tileGrad<T: TensorFlowScalar>(
 ///
 /// Note: the timestamp is computed when the op is executed, not when it is added
 /// to the graph.
-@inlinable @inline(__always)
+@inlinable
 public static func timestamp(
 ) -> Tensor<Double> {
   let op = TFE_Op("Timestamp")
@@ -33801,7 +33776,7 @@ public static func timestamp(
 /// - Outputs:
 ///   - values: The `k` largest elements along each last dimensional slice.
 ///   - indices: The indices of `values` within the last dimension of `input`.
-@inlinable @inline(__always)
+@inlinable
 public static func topK<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   k: Int64,
@@ -33839,7 +33814,7 @@ public static func topK<T: Numeric & TensorFlowScalar>(
 /// - Outputs:
 ///   - values: The `k` largest elements along each last dimensional slice.
 ///   - indices: The indices of `values` within the last dimension of `input`.
-@inlinable @inline(__always)
+@inlinable
 public static func topKV2<T: Numeric & TensorFlowScalar>(
   _ input: Tensor<T>,
   k: Tensor<Int32>,
@@ -33857,7 +33832,7 @@ public static func topKV2<T: Numeric & TensorFlowScalar>(
 ///
 /// The output `y` has the same rank as `x`. The shapes of `x` and `y` satisfy:
 ///   `y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]`
-@inlinable @inline(__always)
+@inlinable
 public static func transpose<
     T: TensorFlowScalar,
     Tperm: BinaryInteger & TensorFlowScalar
@@ -33888,7 +33863,7 @@ public static func transpose<
 ///   - rhs: Shape is `[..., M, K]`.
 ///
 /// - Output output: Shape is `[..., M, K]`.
-@inlinable @inline(__always)
+@inlinable
 public static func tridiagonalSolve<T: FloatingPoint & TensorFlowScalar>(
   diagonals: Tensor<T>,
   rhs: Tensor<T>
@@ -33909,7 +33884,7 @@ public static func tridiagonalSolve<T: FloatingPoint & TensorFlowScalar>(
 ///
 /// *NOTE*: `TruncateDiv` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func truncateDiv<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -33928,7 +33903,7 @@ public static func truncateDiv<T: Numeric & TensorFlowScalar>(
 ///
 /// *NOTE*: `TruncateMod` supports broadcasting. More about broadcasting
 /// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable @inline(__always)
+@inlinable
 public static func truncateMod<T: Numeric & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -33957,7 +33932,7 @@ public static func truncateMod<T: Numeric & TensorFlowScalar>(
 ///
 /// - Output output: A tensor of the specified shape filled with random truncated normal
 ///   values.
-@inlinable @inline(__always)
+@inlinable
 public static func truncatedNormal<
     Dtype: FloatingPoint & TensorFlowScalar,
     T: BinaryInteger & TensorFlowScalar
@@ -34053,7 +34028,7 @@ public static func truncatedNormal<
 ///   - status_code: Same shape as `request`.  Values correspond to tensorflow Status enum codes.
 ///   - status_message: Same shape as `request`.  Values correspond to Status messages
 ///     returned from the RPC calls.
-@inlinable @inline(__always)
+@inlinable
 public static func tryRpc(
   address: StringTensor,
   method: StringTensor,
@@ -34072,7 +34047,7 @@ public static func tryRpc(
   return op.execute(Int(1), Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func twoFloatInputs(
   _ a: Tensor<Float>,
   _ b: Tensor<Float>
@@ -34083,7 +34058,7 @@ public static func twoFloatInputs(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func twoFloatInputsFloatOutput(
   _ a: Tensor<Float>,
   _ b: Tensor<Float>
@@ -34094,7 +34069,7 @@ public static func twoFloatInputsFloatOutput(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func twoFloatInputsIntOutput(
   _ a: Tensor<Float>,
   _ b: Tensor<Float>
@@ -34105,7 +34080,7 @@ public static func twoFloatInputsIntOutput(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func twoFloatOutputs(
 ) -> (a: Tensor<Float>, b: Tensor<Float>) {
   let op = TFE_Op("TwoFloatOutputs")
@@ -34113,7 +34088,7 @@ public static func twoFloatOutputs(
   return op.execute(Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func twoIntInputs(
   _ a: Tensor<Int32>,
   _ b: Tensor<Int32>
@@ -34124,7 +34099,7 @@ public static func twoIntInputs(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func twoIntOutputs(
 ) -> (a: Tensor<Int32>, b: Tensor<Int32>) {
   let op = TFE_Op("TwoIntOutputs")
@@ -34132,7 +34107,7 @@ public static func twoIntOutputs(
   return op.execute(Int(1), Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func typeList<T: TensorArrayProtocol>(
   _ a: T
 ) {
@@ -34142,7 +34117,7 @@ public static func typeList<T: TensorArrayProtocol>(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func typeListRestrict<T: TensorArrayProtocol>(
   _ a: T
 ) {
@@ -34152,7 +34127,7 @@ public static func typeListRestrict<T: TensorArrayProtocol>(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func typeListTwice<T: TensorArrayProtocol>(
   _ a: T,
   _ b: T
@@ -34164,7 +34139,7 @@ public static func typeListTwice<T: TensorArrayProtocol>(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func unary<T: TensorFlowScalar>(
   _ a: Tensor<T>
 ) -> Tensor<T> {
@@ -34194,7 +34169,7 @@ public static func unary<T: TensorFlowScalar>(
 /// shared_name: Instances of Unbatch with the same container and shared_name are
 ///  assumed to possibly belong to the same batch. If left empty, the op name will
 ///  be used as the shared name.
-@inlinable @inline(__always)
+@inlinable
 public static func unbatch<T: TensorFlowScalar>(
   batchedTensor: Tensor<T>,
   batchIndex: Tensor<Int64>,
@@ -34230,7 +34205,7 @@ public static func unbatch<T: TensorFlowScalar>(
 /// shared_name: Instances of UnbatchGrad with the same container and shared_name
 ///  are assumed to possibly belong to the same batch. If left empty, the op name
 ///  will be used as the shared name.
-@inlinable @inline(__always)
+@inlinable
 public static func unbatchGrad<T: TensorFlowScalar>(
   originalInput: Tensor<T>,
   batchIndex: Tensor<Int64>,
@@ -34289,7 +34264,7 @@ public static func unbatchGrad<T: TensorFlowScalar>(
 /// - Outputs:
 ///   - row_splits: A 1D int32 tensor containing the row splits.
 ///   - char_values: A 1D int32 Tensor containing the decoded codepoints.
-@inlinable @inline(__always)
+@inlinable
 public static func unicodeDecode(
   _ input: StringTensor,
   inputEncoding: String,
@@ -34351,7 +34326,7 @@ public static func unicodeDecode(
 ///   - char_values: A 1D int32 Tensor containing the decoded codepoints.
 ///   - char_to_byte_starts: A 1D int32 Tensor containing the byte index in the input string where each
 ///     character in `char_values` starts.
-@inlinable @inline(__always)
+@inlinable
 public static func unicodeDecodeWithOffsets(
   _ input: StringTensor,
   inputEncoding: String,
@@ -34408,7 +34383,7 @@ public static func unicodeDecodeWithOffsets(
 ///     0xFFFD (U+65533).
 ///
 /// - Output output: The 1-D Tensor of strings encoded from the provided unicode codepoints.
-@inlinable @inline(__always)
+@inlinable
 public static func unicodeEncode(
   inputValues: Tensor<Int32>,
   inputSplits: Tensor<Int64>,
@@ -34436,7 +34411,7 @@ public static func unicodeEncode(
 /// - Parameter input: A Tensor of int32 Unicode code points.
 ///
 /// - Output output: A Tensor of int32 script codes corresponding to each input code point.
-@inlinable @inline(__always)
+@inlinable
 public static func unicodeScript(
   _ input: Tensor<Int32>
 ) -> Tensor<Int32> {
@@ -34499,7 +34474,7 @@ public static func unicodeScript(
 ///     `replacement_char`. Default is false.
 ///
 /// - Output output: A string tensor containing unicode text encoded using `output_encoding`.
-@inlinable @inline(__always)
+@inlinable
 public static func unicodeTranscode(
   _ input: StringTensor,
   inputEncoding: String,
@@ -34555,7 +34530,7 @@ public static func unicodeTranscode(
 ///     candidate representing the number of times the candidate is expected
 ///     to occur in a batch of sampled candidates.  If unique=true, then this is a
 ///     probability.
-@inlinable @inline(__always)
+@inlinable
 public static func uniformCandidateSampler(
   trueClasses: Tensor<Int64>,
   numTrue: Int64,
@@ -34599,7 +34574,7 @@ public static func uniformCandidateSampler(
 /// - Outputs:
 ///   - y: 1-D.
 ///   - idx: 1-D.
-@inlinable @inline(__always)
+@inlinable
 public static func unique<
     T: TensorFlowScalar,
     OutIdx: BinaryInteger & TensorFlowScalar
@@ -34668,7 +34643,7 @@ public static func unique<
 ///   - y: A `Tensor`. Unique elements along the `axis` of `Tensor` x.
 ///   - idx: A 1-D Tensor. Has the same type as x that contains the index of each
 ///     value of x in the output y.
-@inlinable @inline(__always)
+@inlinable
 public static func uniqueV2<
     T: TensorFlowScalar,
     Taxis: BinaryInteger & TensorFlowScalar,
@@ -34712,7 +34687,7 @@ public static func uniqueV2<
 ///   - y: 1-D.
 ///   - idx: 1-D.
 ///   - count: 1-D.
-@inlinable @inline(__always)
+@inlinable
 public static func uniqueWithCounts<
     T: TensorFlowScalar,
     OutIdx: BinaryInteger & TensorFlowScalar
@@ -34786,7 +34761,7 @@ public static func uniqueWithCounts<
 ///   - idx: A 1-D Tensor. Has the same type as x that contains the index of each
 ///     value of x in the output y.
 ///   - count: A 1-D Tensor. The count of each value of x in the output y.
-@inlinable @inline(__always)
+@inlinable
 public static func uniqueWithCountsV2<
     T: TensorFlowScalar,
     Taxis: BinaryInteger & TensorFlowScalar,
@@ -34825,7 +34800,7 @@ public static func uniqueWithCountsV2<
 ///   valid range is `[-R, R)`.
 ///
 /// - Output output: The list of tensors unpacked from `value`.
-@inlinable @inline(__always)
+@inlinable
 public static func unpack<T: TensorFlowScalar>(
   value: Tensor<T>,
   num: Int64,
@@ -34855,7 +34830,7 @@ public static func unpack<T: TensorFlowScalar>(
 ///
 /// - Output output: An 2-D (or 1-D if indices is 0-D) tensor where each row has the
 ///   same shape as the indices array.
-@inlinable @inline(__always)
+@inlinable
 public static func unravelIndex<Tidx: BinaryInteger & TensorFlowScalar>(
   indices: Tensor<Tidx>,
   dims: Tensor<Tidx>
@@ -34906,7 +34881,7 @@ public static func unravelIndex<Tidx: BinaryInteger & TensorFlowScalar>(
 /// - Output output: Has same shape as data, except for the first `segment_ids.rank`
 ///   dimensions, which are replaced with a single dimension which has size
 ///   `num_segments`.
-@inlinable @inline(__always)
+@inlinable
 public static func unsortedSegmentMax<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar,
@@ -34960,7 +34935,7 @@ public static func unsortedSegmentMax<
 /// - Output output: Has same shape as data, except for the first `segment_ids.rank`
 ///   dimensions, which are replaced with a single dimension which has size
 ///   `num_segments`.
-@inlinable @inline(__always)
+@inlinable
 public static func unsortedSegmentMin<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar,
@@ -35013,7 +34988,7 @@ public static func unsortedSegmentMin<
 /// - Output output: Has same shape as data, except for the first `segment_ids.rank`
 ///   dimensions, which are replaced with a single dimension which has size
 ///   `num_segments`.
-@inlinable @inline(__always)
+@inlinable
 public static func unsortedSegmentProd<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar,
@@ -35068,7 +35043,7 @@ public static func unsortedSegmentProd<
 /// - Output output: Has same shape as data, except for the first `segment_ids.rank`
 ///   dimensions, which are replaced with a single dimension which has size
 ///   `num_segments`.
-@inlinable @inline(__always)
+@inlinable
 public static func unsortedSegmentSum<
     T: Numeric & TensorFlowScalar,
     Tindices: BinaryInteger & TensorFlowScalar,
@@ -35092,7 +35067,7 @@ public static func unsortedSegmentSum<
 ///
 /// The basic functionality is similar to dequeue with many fewer
 /// capabilities and options.  This Op is optimized for performance.
-@inlinable @inline(__always)
+@inlinable
 public static func unstage<Dtypes: TensorGroup>(
   capacity: Int64 = 0,
   memoryLimit: Int64 = 0,
@@ -35108,7 +35083,7 @@ public static func unstage<Dtypes: TensorGroup>(
   return op.execute(Int(Dtypes._typeList.count))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func unwrapDatasetVariant(
   inputHandle: VariantHandle
 ) -> VariantHandle {
@@ -35145,7 +35120,7 @@ public static func unwrapDatasetVariant(
 /// - Output output: A `Tensor` with the same shape as `values`.  It contains the last scalar index
 ///   into the last dimension where values can be inserted without changing the
 ///   ordered property.
-@inlinable @inline(__always)
+@inlinable
 public static func upperBound<
     T: TensorFlowScalar,
     OutType: BinaryInteger & TensorFlowScalar
@@ -35169,7 +35144,7 @@ public static func upperBound<
 ///   - dtype: the type of this variable. Must agree with the dtypes
 ///     of all ops using this variable.
 ///   - shape: The (possibly partially specified) shape of this variable.
-@inlinable @inline(__always)
+@inlinable
 public static func varHandleOp(
   container: String,
   sharedName: String,
@@ -35190,7 +35165,7 @@ public static func varHandleOp(
 ///
 /// - Output is_initialized: a scalar boolean which is true if the variable has been
 ///   initialized.
-@inlinable @inline(__always)
+@inlinable
 public static func varIsInitializedOp(
   resource: ResourceHandle
 ) -> Tensor<Bool> {
@@ -35209,7 +35184,7 @@ public static func varIsInitializedOp(
 /// # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
 /// shape(t) ==> [2, 2, 3]
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func variableShape<OutType: BinaryInteger & TensorFlowScalar>(
   _ input: ResourceHandle
 ) -> Tensor<OutType> {
@@ -35280,7 +35255,7 @@ public static func variableShape<OutType: BinaryInteger & TensorFlowScalar>(
 ///                   [1, 1, 1],
 ///                   [2, 1, 1]]
 /// ```
-@inlinable @inline(__always)
+@inlinable
 public static func where_<T: TensorFlowScalar>(
   _ input: Tensor<T>
 ) -> Tensor<Int64> {
@@ -35308,7 +35283,7 @@ public static func where_<T: TensorFlowScalar>(
 ///           by T.
 ///
 /// - Output output: A list of output tensors whose types are T.
-@inlinable @inline(__always)
+@inlinable
 public static func while_<
     T: TensorArrayProtocol,
     CondIn: TensorGroup,
@@ -35344,7 +35319,7 @@ public static func while_<
 ///     with this shared_name. Otherwise, the node name is used instead.
 ///
 /// - Output reader_handle: The handle to reference the Reader.
-@inlinable @inline(__always)
+@inlinable
 public static func wholeFileReaderV2(
   container: String,
   sharedName: String
@@ -35365,7 +35340,7 @@ public static func wholeFileReaderV2(
 ///     It must be positive.
 ///   - drop_remainder: A scalar representing whether a window should be dropped in case its size is
 ///     smaller than desired.
-@inlinable @inline(__always)
+@inlinable
 public static func windowDataset(
   inputDataset: VariantHandle,
   size: Tensor<Int64>,
@@ -35394,7 +35369,7 @@ public static func windowDataset(
 /// - Parameter request: A string tensor containing a serialized WorkerHeartbeatRequest
 ///
 /// - Output response: A string tensor containing a serialized WorkerHeartbeatResponse
-@inlinable @inline(__always)
+@inlinable
 public static func workerHeartbeat(
   request: StringTensor
 ) -> StringTensor {
@@ -35403,7 +35378,7 @@ public static func workerHeartbeat(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func wrapDatasetVariant(
   inputHandle: VariantHandle
 ) -> VariantHandle {
@@ -35412,7 +35387,7 @@ public static func wrapDatasetVariant(
   return op.execute(Int(1))
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func writeAudioSummary(
   writer: ResourceHandle,
   step: Tensor<Int64>,
@@ -35438,7 +35413,7 @@ public static func writeAudioSummary(
 /// - Parameters:
 ///   - filename: scalar. The name of the file to which we write the contents.
 ///   - contents: scalar. The content to be written to the output file.
-@inlinable @inline(__always)
+@inlinable
 public static func writeFile(
   filename: StringTensor,
   contents: StringTensor
@@ -35449,7 +35424,7 @@ public static func writeFile(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func writeGraphSummary(
   writer: ResourceHandle,
   step: Tensor<Int64>,
@@ -35462,7 +35437,7 @@ public static func writeGraphSummary(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func writeHistogramSummary<T: Numeric & TensorFlowScalar>(
   writer: ResourceHandle,
   step: Tensor<Int64>,
@@ -35478,7 +35453,7 @@ public static func writeHistogramSummary<T: Numeric & TensorFlowScalar>(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func writeImageSummary<T: Numeric & TensorFlowScalar>(
   writer: ResourceHandle,
   step: Tensor<Int64>,
@@ -35498,7 +35473,7 @@ public static func writeImageSummary<T: Numeric & TensorFlowScalar>(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func writeRawProtoSummary(
   writer: ResourceHandle,
   step: Tensor<Int64>,
@@ -35511,7 +35486,7 @@ public static func writeRawProtoSummary(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func writeScalarSummary<T: Numeric & TensorFlowScalar>(
   writer: ResourceHandle,
   step: Tensor<Int64>,
@@ -35527,7 +35502,7 @@ public static func writeScalarSummary<T: Numeric & TensorFlowScalar>(
   op.execute()
 }
 
-@inlinable @inline(__always)
+@inlinable
 public static func writeSummary<T: TensorFlowScalar>(
   writer: ResourceHandle,
   step: Tensor<Int64>,
@@ -35546,7 +35521,7 @@ public static func writeSummary<T: TensorFlowScalar>(
 }
 
 /// Returns 0 if x == 0, and x / y otherwise, elementwise.
-@inlinable @inline(__always)
+@inlinable
 public static func xdivy<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -35559,7 +35534,7 @@ public static func xdivy<T: FloatingPoint & TensorFlowScalar>(
 }
 
 /// Returns 0 if x == 0, and x * log(y) otherwise, elementwise.
-@inlinable @inline(__always)
+@inlinable
 public static func xlogy<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>,
   _ y: Tensor<T>
@@ -35576,7 +35551,7 @@ public static func xlogy<T: FloatingPoint & TensorFlowScalar>(
 /// - Parameter x: a tensor of type T.
 ///
 /// - Output y: a tensor of the same shape and type as x but filled with zeros.
-@inlinable @inline(__always)
+@inlinable
 public static func zerosLike<T: TensorFlowScalar>(
   _ x: Tensor<T>
 ) -> Tensor<T> {
@@ -35592,7 +35567,7 @@ public static func zerosLike<T: TensorFlowScalar>(
 ///
 ///
 /// \\(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\\)
-@inlinable @inline(__always)
+@inlinable
 public static func zeta<T: FloatingPoint & TensorFlowScalar>(
   _ x: Tensor<T>,
   q: Tensor<T>
@@ -35605,7 +35580,7 @@ public static func zeta<T: FloatingPoint & TensorFlowScalar>(
 }
 
 /// Creates a dataset that zips together `input_datasets`.
-@inlinable @inline(__always)
+@inlinable
 public static func zipDataset(
   inputDatasets: [VariantHandle],
   outputTypes: [TensorDataType],
diff --git a/Sources/TensorFlow/Bindings/generate_wrappers.py b/Sources/TensorFlow/Bindings/generate_wrappers.py
index ed98c2294..ca52c5d4c 100644
--- a/Sources/TensorFlow/Bindings/generate_wrappers.py
+++ b/Sources/TensorFlow/Bindings/generate_wrappers.py
@@ -170,7 +170,7 @@ def __init__(self, op_def, api_def, enum_store, string_valued=False):
 
   def swift_function(self):
     return '''
-{documentation}@inlinable @inline(__always)
+{documentation}@inlinable
 public static func {name}{generics}({input_args}
 ){return_type} {{
   {body}
@@ -613,7 +613,6 @@ def enum_codes(self):
           '\n\n' +
           '  @inlinable\n' +
           '  var cName: String {\n' +
-          '    @inline(__always)\n' +
           '    get {\n' +
           '      switch self {\n' +
           '\n'.join(['      case .{}: return "{}"'.format(
diff --git a/Sources/TensorFlow/Core/ArrayOps.swift b/Sources/TensorFlow/Core/ArrayOps.swift
index e8bfc7d43..b82190cdb 100644
--- a/Sources/TensorFlow/Core/ArrayOps.swift
+++ b/Sources/TensorFlow/Core/ArrayOps.swift
@@ -28,7 +28,7 @@ public extension Raw {
     ///   - shape_and_slices: shape {N}.  The slice specs of the tensors to be saved. Empty strings 
     ///     indicate that they are non-partitioned tensors.
     ///   - tensors: `N` tensors to save.
-    @inlinable @inline(__always)
+    @inlinable
     static func saveV2(
         prefix: StringTensor,
         tensorNames: StringTensor,
@@ -83,7 +83,7 @@ public extension Raw {
     ///
     /// - Output tensors: shape {N}.  The restored tensors, whose shapes are read from the 
     ///   checkpoint directly.
-    @inlinable @inline(__always)
+    @inlinable
     static func restoreV2(
         prefix: StringTensor,
         tensorNames: StringTensor,
diff --git a/Sources/TensorFlow/Core/DataTypes.swift b/Sources/TensorFlow/Core/DataTypes.swift
index 1e95173c5..88ff668c7 100644
--- a/Sources/TensorFlow/Core/DataTypes.swift
+++ b/Sources/TensorFlow/Core/DataTypes.swift
@@ -56,21 +56,6 @@ public protocol _TensorFlowDataTypeCompatible {
     /// The underlying TensorFlow data type.
     @inlinable
     static var tensorFlowDataType: TensorDataType { get }
-
-    // Hooks used by the TFPartition pass for primitive operations on tensors. These should not be
-    // called directly or implemented.
-
-    /// This converts a TensorHandle that is known to have a 0d value into the scalar that it
-    /// produces. Users should call the _TFGetScalarOrDie wrapper function.
-    static func _getScalarOrDie(_ handle: TensorHandle<Self>) -> Self
-
-    /// This converts a TensorHandle into a scalar if it is 0d, or returns nil otherwise. Users
-    /// should call the _TFGetScalar wrapper function.
-    static func _getScalar(_ handle: TensorHandle<Self>) -> Self?
-
-    /// This indicates that it is safe to hoist the specified computation that creates a tensor to 
-    /// being a parameter that is passed in from outside of the tensor program.
-    static func _hoistableClosure(_ fn: () -> TensorHandle<Self>) -> TensorHandle<Self>
 }
 
 /// A scalar data type compatible with TensorFlow.
@@ -98,42 +83,11 @@ public protocol TensorFlowFloatingPoint: TensorFlowScalar & BinaryFloatingPoint
 extension Float: TensorFlowFloatingPoint {}
 extension Double: TensorFlowFloatingPoint {}
 
-// This is the implementation of the _getScalarOrDie requirement for each concrete type below. We 
-// use this round-about approach to implement the global _TFGetScalarOrDie function in order to 
-// ensure that the noinline SIL functions below have non-generic type signatures. This is important 
-// for the inner workings of the partitioning pass.
-private func _TFGetScalarOrDieImpl<Scalar>(_ handle: TensorHandle<Scalar>) -> Scalar {
-    return handle.makeHostCopy().scalar!
-}
-
-// This is the implementation of the _getScalar requirement for each concrete type below. We use 
-// this round-about approach to implement the global _TFGetScalar function in order to ensure that 
-// the noinline SIL functions below have non-generic type signatures.  This is important for the 
-// inner workings of the partitioning pass.
-private func _TFGetScalarImpl<Scalar>(_ handle: TensorHandle<Scalar>) -> Scalar? {
-    return handle.makeHostCopy().scalar
-}
-
 extension Bool: TensorFlowScalar {
     @inlinable
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_BOOL)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_Bool") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<Bool>) -> Bool {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_Bool") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<Bool>) -> Bool? {
-        return _TFGetScalarImpl(handle)
-    }
-
-    @_silgen_name("__tf_hoistable_Bool") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(_ fn: () -> TensorHandle<Bool>) -> TensorHandle<Bool> {
-        return fn()
-    }
 }
 
 extension Int8: TensorFlowScalar {
@@ -141,21 +95,6 @@ extension Int8: TensorFlowScalar {
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_INT8)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_Int8") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<Int8>) -> Int8 {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_Int8") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<Int8>) -> Int8? {
-        return _TFGetScalarImpl(handle)
-    }
-
-    @_silgen_name("__tf_hoistable_Int8") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(_ fn: () -> TensorHandle<Int8>) -> TensorHandle<Int8> {
-        return fn()
-    }
 }
 
 extension UInt8: TensorFlowScalar {
@@ -163,21 +102,6 @@ extension UInt8: TensorFlowScalar {
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_UINT8)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_UInt8") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<UInt8>) -> UInt8 {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_UInt8") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<UInt8>) -> UInt8? {
-        return _TFGetScalarImpl(handle)
-    }
-
-    @_silgen_name("__tf_hoistable_UInt8") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(_ fn: () -> TensorHandle<UInt8>) -> TensorHandle<UInt8> {
-        return fn()
-    }
 }
 
 extension Int16: TensorFlowScalar {
@@ -185,21 +109,6 @@ extension Int16: TensorFlowScalar {
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_INT16)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_Int16") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<Int16>) -> Int16 {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_Int16") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<Int16>) -> Int16? {
-        return _TFGetScalarImpl(handle)
-    }
-
-    @_silgen_name("__tf_hoistable_Int16") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(_ fn: () -> TensorHandle<Int16>) -> TensorHandle<Int16> {
-        return fn()
-    }
 }
 
 extension UInt16: TensorFlowScalar {
@@ -207,21 +116,6 @@ extension UInt16: TensorFlowScalar {
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_UINT16)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_UInt16") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<UInt16>) -> UInt16 {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_UInt16") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<UInt16>) -> UInt16? {
-        return _TFGetScalarImpl(handle)
-    }
-
-    @_silgen_name("__tf_hoistable_UInt16") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(_ fn: () -> TensorHandle<UInt16>) -> TensorHandle<UInt16> {
-        return fn()
-    }
 }
 
 extension Int32: TensorFlowScalar {
@@ -229,21 +123,6 @@ extension Int32: TensorFlowScalar {
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_INT32)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_Int32") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<Int32>) -> Int32 {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_Int32") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<Int32>) -> Int32? {
-        return _TFGetScalarImpl(handle)
-    }
-
-    @_silgen_name("__tf_hoistable_Int32") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(_ fn: () -> TensorHandle<Int32>) -> TensorHandle<Int32> {
-        return fn()
-    }
 }
 
 extension UInt32: TensorFlowScalar {
@@ -251,21 +130,6 @@ extension UInt32: TensorFlowScalar {
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_UINT32)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_UInt32") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<UInt32>) -> UInt32 {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_UInt32") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<UInt32>) -> UInt32? {
-        return _TFGetScalarImpl(handle)
-    }
-
-    @_silgen_name("__tf_hoistable_UInt32") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(_ fn: () -> TensorHandle<UInt32>) -> TensorHandle<UInt32> {
-        return fn()
-    }
 }
 
 extension Int64: TensorFlowScalar {
@@ -273,21 +137,6 @@ extension Int64: TensorFlowScalar {
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_INT64)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_Int64") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<Int64>) -> Int64 {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_Int64") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<Int64>) -> Int64? {
-        return _TFGetScalarImpl(handle)
-    }
-
-    @_silgen_name("__tf_hoistable_Int64") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(_ fn: () -> TensorHandle<Int64>) -> TensorHandle<Int64> {
-        return fn()
-    }
 }
 
 extension UInt64: TensorFlowScalar {
@@ -295,21 +144,6 @@ extension UInt64: TensorFlowScalar {
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_UINT64)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_UInt64") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<UInt64>) -> UInt64 {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_UInt64") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<UInt64>) -> UInt64? {
-        return _TFGetScalarImpl(handle)
-    }
-
-    @_silgen_name("__tf_hoistable_UInt64") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(_ fn: () -> TensorHandle<UInt64>) -> TensorHandle<UInt64> {
-        return fn()
-    }
 }
 
 @_fixed_layout
@@ -323,23 +157,6 @@ extension BFloat16: TensorFlowScalar {
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_BFLOAT16)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_BFloat16") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<BFloat16>) -> BFloat16 {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_BFloat16") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<BFloat16>) -> BFloat16? {
-        return _TFGetScalarImpl(handle)
-    }
-
-    @_silgen_name("__tf_hoistable_BFloat16") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(
-        _ fn: () -> TensorHandle<BFloat16>
-    ) -> TensorHandle<BFloat16> {
-        return fn()
-    }
 }
 
 extension Float: TensorFlowScalar {
@@ -347,21 +164,6 @@ extension Float: TensorFlowScalar {
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_FLOAT)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_Float") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<Float>) -> Float {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_Float") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<Float>) -> Float? {
-        return _TFGetScalarImpl(handle)
-    }
-
-    @_silgen_name("__tf_hoistable_Float") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(_ fn: () -> TensorHandle<Float>) -> TensorHandle<Float> {
-        return fn()
-    }
 }
 
 extension Double: TensorFlowScalar {
@@ -369,21 +171,6 @@ extension Double: TensorFlowScalar {
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_DOUBLE)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_Double") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<Double>) -> Double {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_Double") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<Double>) -> Double? {
-        return _TFGetScalarImpl(handle)
-    }
-
-    @_silgen_name("__tf_hoistable_Double") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(_ fn: () -> TensorHandle<Double>) -> TensorHandle<Double> {
-        return fn()
-    }
 }
 
 extension String: _TensorFlowDataTypeCompatible {
@@ -391,19 +178,4 @@ extension String: _TensorFlowDataTypeCompatible {
     public static var tensorFlowDataType: TensorDataType {
         return TensorDataType(TF_STRING)
     }
-
-    @_silgen_name("__tf_get_scalar_or_die_String") @inline(never)
-    public static func _getScalarOrDie(_ handle: TensorHandle<String>) -> String {
-        return _TFGetScalarOrDieImpl(handle)
-    }
-
-    @_silgen_name("__tf_get_scalar_String") @inline(never)
-    public static func _getScalar(_ handle: TensorHandle<String>) -> String? {
-        return _TFGetScalarImpl(handle)
-    }
-    
-    @_silgen_name("__tf_hoistable_String") @_optimize(none) @inline(never)
-    public static func _hoistableClosure(_ fn: () -> TensorHandle<String>) -> TensorHandle<String> {
-        return fn()
-    }
 }
diff --git a/Sources/TensorFlow/Core/Helpers.swift b/Sources/TensorFlow/Core/Helpers.swift
index e1ed01225..63e89f4c7 100644
--- a/Sources/TensorFlow/Core/Helpers.swift
+++ b/Sources/TensorFlow/Core/Helpers.swift
@@ -14,82 +14,6 @@
 
 import CTensorFlow
 
-//===------------------------------------------------------------------------------------------===//
-// Tensor
-//===------------------------------------------------------------------------------------------===//
-
-/// This function converts a `TensorHandle` that is known to have a 0-d value
-/// into the scalar that it produces. This is intended for use in op definitions
-/// where it is known that the op always returns a 0-d tensor. It is not for use
-/// in general code.
-@inlinable @inline(__always)
-public func _TFGetScalarOrDie<Scalar: TensorFlowScalar>(_ handle: TensorHandle<Scalar>) -> Scalar {
-  return Scalar._getScalarOrDie(handle)
-}
-
-/// This function converts a `TensorHandle` into a scalar if it is 0-d, or returns nil otherwise.
-@inlinable @inline(__always)
-public func _TFGetScalar<Scalar: TensorFlowScalar>(_ handle: TensorHandle<Scalar>) -> Scalar? {
-  return Scalar._getScalar(handle)
-}
-
-/// This compiler builtin is known by the partitioning pass, which recognizes it
-/// and promotes calls to it to being in graph when it can. This signature was
-/// designed to align with the requirements of the `Const` TensorFlow operation.
-@inlinable @inline(never)
-@_silgen_name("__tf_tensor_from_scalars")
-public func _TFTensorFromScalars<Scalar: TensorFlowScalar>(
-    _ scalars: [Scalar], shape: [Int]
-) -> TensorHandle<Scalar> {
-    let contiguousSize = shape.reduce(1, *)
-    precondition(scalars.count == contiguousSize, "The number of scalars does not match the shape.")
-    return TensorHandle(
-        shape: shape,
-        scalarsInitializer: { addr in
-            scalars.withUnsafeBufferPointer { ptr in
-                addr.assign(from: ptr.baseAddress!, count: contiguousSize)
-            }
-        })
-}
-
-/// In graph mode, the deabstraction pass transforms this function call to
-/// either a "Const" graph_op (if `scalar` is a compile-time constant), or a
-/// "tfc.scalarToTensor" graph_op. In the latter case, the partition pass uses
-/// it to do scalar promotion, and transforms it away before entering graph
-/// lowering. e.g. For user code:
-///   let x_scalar = x_tensor.mean()
-///   let y_scalar = y_tensor.mean()
-///   let z_scalar = x_scalar + y_scalar
-///   let z_tensor = Tensor(z_scalar)
-///
-/// The scalar addition can be promoted into graph, through the
-/// "tfc.scalarToTensor" graph_op generated from Tensor(z_scalar). In this
-/// example, the _getScalarOrDie() call generated from mean() will be "cancelled
-/// out" with "tfc.scalarToTensor", such that we avoid generating scalar on the
-/// host, and then converting it back to a graph tensor.
-///
-/// In eager mode, this function is executed directly.
-@inlinable @inline(never)
-@_silgen_name("__tf_tensor_from_scalar")
-public func _TFTensorFromScalar<Scalar: TensorFlowScalar>(
-    _ scalar: Scalar
-) -> TensorHandle<Scalar> {
-    return _TFTensorFromScalars([scalar], shape: [])
-}
-
-@inlinable @inline(never)
-@_silgen_name("__tf_tensor_from_scalars_1d")
-public func _TFTensorFromScalars1D<Scalar: TensorFlowScalar>(
-    _ scalars: [Scalar]
-) -> TensorHandle<Scalar> {
-    return _TFTensorFromScalars(scalars, shape: [scalars.count])
-}
-
-@inlinable @inline(__always)
-public func _TFHoistable<Scalar>(_ fn: () -> TensorHandle<Scalar>) -> TensorHandle<Scalar> {
-    return Scalar._hoistableClosure(fn)
-}
-
 //===------------------------------------------------------------------------------------------===//
 // StringTensor
 //===------------------------------------------------------------------------------------------===//
diff --git a/Sources/TensorFlow/Core/ShapedArray.swift b/Sources/TensorFlow/Core/ShapedArray.swift
index f62f4a5eb..e434cbfec 100644
--- a/Sources/TensorFlow/Core/ShapedArray.swift
+++ b/Sources/TensorFlow/Core/ShapedArray.swift
@@ -546,7 +546,7 @@ public extension ShapedArray {
     /// - Parameters:
     ///   - shape: The shape of the `ShapedArray`.
     ///   - repeatedValue: The scalar value to repeat.
-    @inlinable @inline(__always)
+    @inlinable
     @available(*, deprecated, renamed: "init(repeating:shape:)")
     init(shape: __owned [Int], repeating repeatedValue: __owned Scalar) {
         self.init(repeating: repeatedValue, shape: shape)
@@ -701,7 +701,7 @@ public extension Tensor {
 // Array literal conversion.
 extension ShapedArray: ExpressibleByArrayLiteral where Scalar: TensorFlowScalar {
     public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
-    @inlinable @inline(__always)
+    @inlinable
     public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...) {
         self = Tensor<Scalar>(_tensorElementLiterals: elements).array
     }
@@ -896,7 +896,7 @@ public extension ShapedArraySlice {
     /// - Parameters:
     ///   - repeatedValue: The scalar value to repeat.
     ///   - shape: The shape of the `ShapedArraySlice`.
-    @inlinable @inline(__always)
+    @inlinable
     @available(*, deprecated, renamed: "init(repeating:shape:)")
     init(shape: __owned [Int], repeating repeatedValue: __owned Scalar) {
         self.init(repeating: repeatedValue, shape: shape)
@@ -1063,7 +1063,7 @@ public extension ShapedArraySlice where Scalar: TensorFlowScalar {
 // Array literal conversion.
 extension ShapedArraySlice: ExpressibleByArrayLiteral where Scalar: TensorFlowScalar {
     public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
-    @inlinable @inline(__always)
+    @inlinable
     public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...) {
         self.init(base: Tensor(_tensorElementLiterals: elements).array)
     }
diff --git a/Sources/TensorFlow/Core/StringTensor.swift b/Sources/TensorFlow/Core/StringTensor.swift
index 976850f99..f7f4aaa06 100644
--- a/Sources/TensorFlow/Core/StringTensor.swift
+++ b/Sources/TensorFlow/Core/StringTensor.swift
@@ -37,20 +37,71 @@ public struct StringTensor {
 //===------------------------------------------------------------------------------------------===//
 
 public extension StringTensor {
-    /// Creates a tensor from a scalar value.
-    @inlinable @inline(__always)
-    init(_ value: String) {
-        self.init(handle: _TFStringTensorFromString(value))
+    @inlinable
+    init(shape: TensorShape, scalars: [String]) {
+        let contiguousSize = shape.contiguousSize
+        precondition(scalars.count == contiguousSize,
+                     "The number of scalars does not match the shape.")
+
+        // utf8CString is null-terminated. TF APIs want the strings without null-terminators.
+        let cStrings = scalars.map { $0.utf8CString.dropLast() }
+        let tfEncodedSizes = cStrings.map { TF_StringEncodedSize($0.count) }
+
+        // Format information copied from tensorflow/c/c_api.h:
+        // The format for TF_STRING tensors is:
+        //   start_offset: array[uint64]
+        //   data:         byte[...]
+        //
+        //   The string length (as a varint), followed by the contents of the string is encoded at 
+        //   data[start_offset[i]]].
+        // The size of the "start_offset" region.
+        let startOffsetsByteCount = scalars.count * MemoryLayout<UInt64>.stride
+
+        // The size of the "data" region.
+        let dataByteCount = tfEncodedSizes.reduce(0, +) * MemoryLayout<UInt8>.stride
+
+        let handle = TensorHandle<String>(
+            shape: shape.dimensions,
+            byteCount: startOffsetsByteCount + dataByteCount,
+            bufferInitializer: { tensorBuffer in
+                // Initialize the "start_offset" region.
+                var startOffset: UInt64 = 0
+                var startOffsetAddr =
+                tensorBuffer.bindMemory(to: UInt64.self, capacity: scalars.count)
+                for tfEncodedSize in tfEncodedSizes {
+                    startOffsetAddr.initialize(to: startOffset)
+                    startOffsetAddr = startOffsetAddr.advanced(by: 1)
+                    startOffset = startOffset + UInt64(tfEncodedSize)
+                }
+
+                // Initialize the "data" region.
+                var dataAddr = tensorBuffer.advanced(by: startOffsetsByteCount)
+                    .bindMemory(to: Int8.self, capacity: dataByteCount)
+                let status = TF_NewStatus()
+                for (cString, tfEncodedSize) in zip(cStrings, tfEncodedSizes) {
+                    _ = cString.withUnsafeBufferPointer { buffer in
+                        TF_StringEncode(
+                            buffer.baseAddress, buffer.count, dataAddr, tfEncodedSize, status)
+                    }
+                    checkOk(status)
+                    dataAddr = dataAddr.advanced(by: tfEncodedSize)
+                }
+                TF_DeleteStatus(status)
+            })
+        self.init(handle: handle)
     }
 
-    /// Creates a 1D tensor from contiguous scalars.
-    ///
-    /// - Parameters:
-    ///   - vector: The scalar contents of the tensor.
-    @inlinable @inline(__always)
-    init(_ vector: [String]) {
-        self.init(handle: _TFStringTensorFromStrings1D(vector))
+    /// Creates a 0-D `StringTensor` from a scalar value.
+    @inlinable
+    init(_ value: String) {
+        self.init(shape: [], scalars: [value])
     }
+
+    /// Creates a 1-D `StringTensor` in from contiguous scalars.
+    @inlinable
+    init(_ scalars: [String]) {
+	    self.init(shape: [scalars.count], scalars: scalars)
+	}
 }
 
 //===------------------------------------------------------------------------------------------===//
diff --git a/Sources/TensorFlow/Core/Tensor.swift b/Sources/TensorFlow/Core/Tensor.swift
index e44e64f12..f03f8a09f 100644
--- a/Sources/TensorFlow/Core/Tensor.swift
+++ b/Sources/TensorFlow/Core/Tensor.swift
@@ -42,17 +42,15 @@ public extension Tensor {
     /// The number of dimensions of the `Tensor`.
     @inlinable
     var rank: Int {
-        @inline(__always)
         @_semantics("autodiff.nonvarying")
         get {
-            return Int(_TFGetScalarOrDie(rankTensor.handle))
+            return Int(rankTensor.scalar!)
         }
     }
 
-    /// The dimensions of the `Tensor`.
+    /// The shape of the `Tensor`.
     @inlinable
     var shape: TensorShape {
-        @inline(__always)
         @_semantics("autodiff.nonvarying")
         get {
             return TensorShape(shapeTensor.scalars.map(Int.init))
@@ -62,9 +60,8 @@ public extension Tensor {
     /// The number of scalars in the `Tensor`.
     @inlinable
     var scalarCount: Int {
-        @inline(__always)
         get {
-            return Int(_TFGetScalarOrDie(scalarCountTensor.handle))
+            return Int(scalarCountTensor.scalar!)
         }
     }
 
@@ -104,20 +101,14 @@ public extension Tensor {
     /// Returns `true` if `rank` is equal to 0 and `false` otherwise.
     @inlinable
     var isScalar: Bool {
-        @inline(__always)
-        get {
-            return rank == 0
-        }
+        return rank == 0
     }
 
     /// Returns the single scalar element if `rank` is equal to 0 and `nil`
     /// otherwise.
     @inlinable
     var scalar: Scalar? {
-        @inline(__always)
-        get {
-            return Scalar(self)
-        }
+        return Scalar(self)
     }
 
     /// Reshape to scalar.
@@ -125,7 +116,7 @@ public extension Tensor {
     @inlinable
     @differentiable(wrt: self, vjp: _vjpScalarized where Scalar: TensorFlowFloatingPoint)
     func scalarized() -> Scalar {
-        return _TFGetScalarOrDie(reshaped(to: []).handle)
+        return reshaped(to: []).scalar!
     }
 }
 
@@ -137,9 +128,9 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
 }
 
 public extension TensorFlowScalar {
-    @inlinable @inline(__always)
+    @inlinable
     init?(_ tensor: Tensor<Self>) {
-        guard let scalar = _TFGetScalar(tensor.handle) else {
+        guard let scalar = tensor.scalar else {
             return nil
         }
         self = scalar
@@ -153,12 +144,9 @@ public extension TensorFlowScalar {
 public extension Tensor {
     @inlinable
     var array: ShapedArray<Scalar> {
-        @inline(__always)
-        get {
-            debugLog("Returning a host copy of array.")
-            internalConsistencyCheck(handle.isConcrete)
-	        return handle.makeHostCopy()
-        }
+        debugLog("Returning a host copy of array.")
+        internalConsistencyCheck(handle.isConcrete)
+	    return handle.makeHostCopy()
     }
 
     @inlinable
@@ -172,11 +160,11 @@ public extension Tensor {
 //===------------------------------------------------------------------------------------------===//
 
 public extension Tensor {
-    /// Creates a tensor from a scalar value.
-    @inlinable @inline(__always)
+    /// Creates a 0-D tensor from a scalar value.
+    @inlinable
     @differentiable(vjp: _vjpScalarInit where Scalar: TensorFlowFloatingPoint)
     init(_ value: Scalar) {
-        self.init(handle: _TFTensorFromScalar(value))
+        self.init(shape: [], scalars: [value])
     }
 }
 
@@ -188,23 +176,16 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
 }
 
 public extension Tensor {
-    /// Creates a 1D tensor from contiguous scalars.
-    ///
-    /// - Parameters:
-    ///   - vector: The scalar contents of the tensor.
-    @inlinable @inline(__always)
-    init(_ vector: [Scalar]) {
-        self.init(handle: _TFTensorFromScalars1D(vector))
+    /// Creates a 1D tensor from scalars.
+    @inlinable
+    init(_ scalars: [Scalar]) {
+        self.init(shape: [scalars.count], scalars: scalars)
     }
 
-    /// Creates a 1D tensor from contiguous scalars.
-    ///
-    /// - Parameters:
-    ///   - vector: The scalar contents of the tensor.
-    @inlinable @inline(__always)
+    /// Creates a 1D tensor from scalars.
+    @inlinable
     init<C: RandomAccessCollection>(_ vector: C) where C.Element == Scalar {
-        let handle = _TFHoistable {
-        TensorHandle<Scalar>(
+        let handle = TensorHandle<Scalar>(
             shape: [vector.count],
             scalarsInitializer: { addr in
                 var currentAddr = addr
@@ -213,7 +194,6 @@ public extension Tensor {
                     currentAddr = currentAddr.advanced(by: 1)
                 }
             })
-        }
         self.init(handle: handle)
     }
 
@@ -223,11 +203,11 @@ public extension Tensor {
     ///   - shape: The shape of the tensor.
     ///   - scalars: The scalar contents of the tensor.
     /// - Precondition: The number of scalars must equal the product of the dimensions of the shape.
-    @inlinable @inline(__always)
+    @inlinable
     init(shape: TensorShape, scalars: [Scalar]) {
-        // NOTE: We use `_TFTensorFromScalars` here so the compiler can try to promote constants and
-        // avoid copies.
-        self.init(handle: _TFTensorFromScalars(scalars, shape: shape.dimensions))
+        self = scalars.withUnsafeBufferPointer { bufferPointer in
+	        Tensor(shape: shape, scalars: bufferPointer)
+	    }
     }
 
     /// Creates a tensor with the specified shape and contiguous scalars in row-major order.
@@ -237,16 +217,14 @@ public extension Tensor {
     ///   - scalars: The scalar contents of the tensor.
     /// - Precondition: The number of scalars must equal the product of the
     ///   dimensions of the shape.
-    @inlinable @inline(__always)
+    @inlinable
     init(shape: TensorShape, scalars: UnsafeBufferPointer<Scalar>) {
-        let handle: TensorHandle<Scalar> = _TFHoistable {
-            precondition(scalars.count == shape.contiguousSize)
-            return TensorHandle<Scalar>(
-                shape: shape.dimensions,
-                scalarsInitializer: { address in
-                    address.initialize(from: scalars.baseAddress!, count: shape.contiguousSize)
-                })
-        }
+        precondition(scalars.count == shape.contiguousSize)
+        let handle = TensorHandle<Scalar>(
+            shape: shape.dimensions,
+            scalarsInitializer: { address in
+                address.initialize(from: scalars.baseAddress!, count: shape.contiguousSize)
+            })
         self.init(handle: handle)
     }
 
@@ -257,20 +235,18 @@ public extension Tensor {
     ///   - scalars: The scalar contents of the tensor.
     /// - Precondition: The number of scalars must equal the product of the
     ///   dimensions of the shape.
-    @inlinable @inline(__always)
+    @inlinable
     init<C: RandomAccessCollection>(shape: TensorShape, scalars: C) where C.Element == Scalar {
-        let handle: TensorHandle<Scalar> = _TFHoistable {
-            precondition(scalars.count == shape.contiguousSize)
-            return TensorHandle<Scalar>(
-                shape: shape.dimensions,
-                scalarsInitializer: { addr in
-                    var currentAddr = addr
-                    for scalar in scalars {
-                        currentAddr.initialize(to: scalar)
-                        currentAddr = currentAddr.advanced(by: 1)
-                    }
-                })
-        }
+        precondition(scalars.count == shape.contiguousSize)
+        let handle = TensorHandle<Scalar>(
+            shape: shape.dimensions,
+            scalarsInitializer: { addr in
+                var currentAddr = addr
+                for scalar in scalars {
+                    currentAddr.initialize(to: scalar)
+                    currentAddr = currentAddr.advanced(by: 1)
+                }
+            })
         self.init(handle: handle)
     }
 }
@@ -338,7 +314,7 @@ public struct _TensorElementLiteral<Scalar>: TensorProtocol where Scalar: Tensor
 extension _TensorElementLiteral: ExpressibleByBooleanLiteral
     where Scalar: ExpressibleByBooleanLiteral {
     public typealias BooleanLiteralType = Scalar.BooleanLiteralType
-    @inlinable @inline(__always)
+    @inlinable
     public init(booleanLiteral: BooleanLiteralType) {
         tensor = Tensor(Scalar(booleanLiteral: booleanLiteral))
     }
@@ -347,7 +323,7 @@ extension _TensorElementLiteral: ExpressibleByBooleanLiteral
 extension _TensorElementLiteral: ExpressibleByIntegerLiteral
     where Scalar: ExpressibleByIntegerLiteral {
     public typealias IntegerLiteralType = Scalar.IntegerLiteralType
-    @inlinable @inline(__always)
+    @inlinable
     public init(integerLiteral: IntegerLiteralType) {
         tensor = Tensor(Scalar(integerLiteral: integerLiteral))
     }
@@ -356,7 +332,7 @@ extension _TensorElementLiteral: ExpressibleByIntegerLiteral
 extension _TensorElementLiteral: ExpressibleByFloatLiteral
     where Scalar: ExpressibleByFloatLiteral {
     public typealias FloatLiteralType = Scalar.FloatLiteralType
-    @inlinable @inline(__always)
+    @inlinable
     public init(floatLiteral: FloatLiteralType) {
         tensor = Tensor(Scalar(floatLiteral: floatLiteral))
     }
@@ -364,7 +340,7 @@ extension _TensorElementLiteral: ExpressibleByFloatLiteral
 
 extension _TensorElementLiteral: ExpressibleByArrayLiteral {
     public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
-    @inlinable @inline(__always)
+    @inlinable
     public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...) {
         tensor = Raw.pack(elements.map { $0.tensor })
     }
@@ -377,13 +353,13 @@ extension Tensor: ExpressibleByArrayLiteral {
     /// Creates a tensor initialized with the given elements.
     /// - Note: This is for conversion from tensor element literals. This is a
     ///   separate method because `ShapedArray` initializers need to call it.
-    @inlinable @inline(__always)
+    @inlinable
     internal init(_tensorElementLiterals elements: [_TensorElementLiteral<Scalar>]) {
         self = Raw.pack(elements.map { $0.tensor })
     }
 
     /// Creates a tensor initialized with the given elements.
-    @inlinable @inline(__always)
+    @inlinable
     public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...) {
         self.init(_tensorElementLiterals: elements)
     }
@@ -508,7 +484,7 @@ extension Tensor: AdditiveArithmetic where Scalar: Numeric {
 
     /// Adds two tensors and produces their sum.
     /// - Note: `+` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     @differentiable(vjp: _vjpAdd(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
     public static func + (lhs: Tensor, rhs: Tensor) -> Tensor {
         return Raw.add(lhs, rhs)
@@ -516,7 +492,7 @@ extension Tensor: AdditiveArithmetic where Scalar: Numeric {
 
     /// Subtracts one tensor from another and produces their difference.
     /// - Note: `-` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     @differentiable(vjp: _vjpSubtract(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
     public static func - (lhs: Tensor, rhs: Tensor) -> Tensor {
         return Raw.sub(lhs, rhs)
diff --git a/Sources/TensorFlow/Core/TensorHandle.swift b/Sources/TensorFlow/Core/TensorHandle.swift
index a377f01b4..267da89e5 100644
--- a/Sources/TensorFlow/Core/TensorHandle.swift
+++ b/Sources/TensorFlow/Core/TensorHandle.swift
@@ -120,52 +120,6 @@ internal extension TensorHandle {
     }
 }
 
-extension TensorHandle: TensorSendableReceivable {
-    @inlinable
-    static func receiveFromAccelerator(
-        _ computation: _TensorComputation,
-        _ tensorID: Int
-    ) -> TensorHandle<Scalar> {
-        debugLog("Receiving tensor of id \(tensorID) and type \(Scalar.self).")
-        let status = TF_NewStatus()
-        internalConsistencyCheck(status != nil)
-        let tensorHandle: TensorHandle<Scalar>
-        let context = _ExecutionContext.global
-        let cTensorHandle = TFE_DequeueNamedTensorFromCtx(
-            context.eagerContext, Int32(tensorID),
-            Scalar.tensorFlowDataType._cDataType, status)
-        checkOk(status)
-        tensorHandle = TensorHandle<Scalar>(_owning: cTensorHandle!)
-        if _RuntimeConfig.printsDebugLog {
-            debugLog("The received tensor of id \(tensorID) has content:")
-            dumpTensorContent(tensorHandle._cTensorHandle, Scalar.self)
-        }
-        return tensorHandle
-    }
-
-    @inlinable
-    func sendToAccelerator(_ computation: _TensorComputation, _ tensorID: Int) {
-        if _RuntimeConfig.printsDebugLog {
-            debugLog("Sending tensor of id \(tensorID) and type \(Scalar.self) with:")
-            dumpTensorContent(_cTensorHandle, Scalar.self)
-        }
-        let status = TF_NewStatus()
-        internalConsistencyCheck(status != nil)
-        let context = _ExecutionContext.global
-        TFE_EnqueueNamedTensorFromCtx(context.eagerContext, Int32(tensorID), _cTensorHandle, status)
-        debugLog("Tensor is sent.")
-        checkOk(status)
-        TF_DeleteStatus(status)
-    }
-
-    @inlinable
-    static func scalar(_ scalar: Scalar) -> TensorHandle<Scalar> {
-        debugLog("Creating a tensor from scalar \(scalar).")
-        let cTensorHandle = _TFCCreateCTensorHandle(scalar, Scalar.tensorFlowDataType._cDataType)
-        return TensorHandle<Scalar>(_owning: cTensorHandle)
-    }
-}
-
 /// `ResourceHandle` is the type used by ops to represent TensorFlow "resource" values.
 public final class ResourceHandle: _AnyTensorHandle {
     @usableFromInline
@@ -180,43 +134,6 @@ public final class ResourceHandle: _AnyTensorHandle {
     }
 }
 
-extension ResourceHandle: TensorSendableReceivable {
-    @inlinable
-    static func receiveFromAccelerator(
-        _ computation: _TensorComputation,
-        _ tensorID: Int
-    ) -> ResourceHandle {
-        debugLog("Receiving resource tensor of id \(tensorID).")
-        let status = TF_NewStatus()
-        let context = _ExecutionContext.global
-        let cTensorHandle: CTensorHandle! = TFE_DequeueNamedTensorFromCtx(
-            context.eagerContext, Int32(tensorID), TF_RESOURCE, status)
-        checkOk(status)
-        TF_DeleteStatus(status)
-        debugLog("Done receiving resource tensor of id \(tensorID).")
-        return ResourceHandle(owning: cTensorHandle)
-    }
-
-    @inlinable
-    func sendToAccelerator(_ computation: _TensorComputation, _ tensorID: Int) {
-        debugLog("Sending resource tensor of id \(tensorID).")
-        let status = TF_NewStatus()
-        let context = _ExecutionContext.global
-        TFE_EnqueueNamedTensorFromCtx(
-            context.eagerContext, Int32(tensorID), self._cTensorHandle, status)
-        TF_DeleteStatus(status)
-        debugLog("Done sending resource tensor of id \(tensorID).")
-    }
-
-    // TODO: Remove this dummy `Scalar` typealias, currently required in order to conform to
-    // `TensorSendableReceivable`.
-    @usableFromInline typealias Scalar = Float
-    @inlinable
-    static func scalar(_ scalar: Scalar) -> ResourceHandle {
-        fatalError("Unsupported")
-    }
-}
-
 /// `VariantHandle` is the type used by ops to represent TensorFlow "variant" values.
 public final class VariantHandle: _AnyTensorHandle {
     @usableFromInline
@@ -230,40 +147,3 @@ public final class VariantHandle: _AnyTensorHandle {
         debugLog("Returning from deinit of VariantHandle.")
     }
 }
-
-extension VariantHandle: TensorSendableReceivable {
-    @inlinable
-    static func receiveFromAccelerator(
-        _ computation: _TensorComputation,
-        _ tensorID: Int
-    ) -> VariantHandle {
-        debugLog("Receiving variant tensor of id \(tensorID).")
-        let status = TF_NewStatus()
-        let context = _ExecutionContext.global
-        let cTensorHandle: CTensorHandle! = TFE_DequeueNamedTensorFromCtx(
-            context.eagerContext, Int32(tensorID), TF_VARIANT, status)
-        checkOk(status)
-        TF_DeleteStatus(status)
-        debugLog("Done receiving variant tensor of id \(tensorID).")
-        return VariantHandle(owning: cTensorHandle)
-    }
-
-    @inlinable
-    func sendToAccelerator(_ computation: _TensorComputation, _ tensorID: Int) {
-        debugLog("Sending variant tensor of id \(tensorID).")
-        let status = TF_NewStatus()
-        let context = _ExecutionContext.global
-        TFE_EnqueueNamedTensorFromCtx(
-            context.eagerContext, Int32(tensorID), self._cTensorHandle, status)
-        TF_DeleteStatus(status)
-        debugLog("Done sending variant tensor of id \(tensorID).")
-    }
-
-    // TODO: Remove this dummy `Scalar` typealias, currently required in order to conform to
-    // `TensorSendableReceivable`.
-    @usableFromInline typealias Scalar = Float
-    @inlinable
-    static func scalar(_ scalar: Scalar) -> VariantHandle {
-        fatalError("Unsupported")
-    }
-}
diff --git a/Sources/TensorFlow/Core/TensorProtocol.swift b/Sources/TensorFlow/Core/TensorProtocol.swift
index ca93b342a..e179bc1ba 100644
--- a/Sources/TensorFlow/Core/TensorProtocol.swift
+++ b/Sources/TensorFlow/Core/TensorProtocol.swift
@@ -24,28 +24,3 @@ public protocol TensorProtocol {
     /// - Note: Do NOT remove this. This is a compiler requirement.
     init(handle: TensorHandle<Scalar>)
 }
-
-/// The protocol on tensor sends and receives.
-///
-/// - Note: The compiler knows about this protocol and generates code to use it. So changing the 
-///   protocol design requires changing the compiler accordingly too.
-protocol TensorSendableReceivable {
-    associatedtype Scalar
-
-    /// Receive a tensor based on a tensor computation handle (equivalent to a TF session handle),
-    /// and a tensor ID.
-    static func receiveFromAccelerator(_ computation: _TensorComputation, _ tensorID: Int) -> Self
-
-    /// Send a tensor of `this` instance based on a tensor computation handle (equivalent to a TF
-    /// session handle), and a tensor ID.
-    func sendToAccelerator(_ computation: _TensorComputation, _ tensorID: Int)
-
-    /// Create a scalar tensor. It can be used by the host program to send a scalar value to
-    /// accelerator.
-    ///
-    /// - Note: This is different from protocol method `TensorFlowScalar._makeScalarTensor()`, a 
-    ///   marker function to assist compiler in generating Accelerator code, and has no runtime
-    ///   effects.
-    static func scalar(_ scalar: Scalar) -> Self
-}
-
diff --git a/Sources/TensorFlow/Core/TensorShape.swift b/Sources/TensorFlow/Core/TensorShape.swift
index 42eb5c012..33db70361 100644
--- a/Sources/TensorFlow/Core/TensorShape.swift
+++ b/Sources/TensorFlow/Core/TensorShape.swift
@@ -26,7 +26,7 @@ public struct TensorShape: ExpressibleByArrayLiteral {
 
     /// Initialize with an array of dimensions. The rank of the tensor is the length of the array.
     /// - Parameter dimensions: The shape dimensions.
-    @inlinable @inline(__always)
+    @inlinable
     public init(_ dimensions: [Int]) {
         self.dimensions = dimensions
     }
@@ -34,7 +34,7 @@ public struct TensorShape: ExpressibleByArrayLiteral {
     /// Initialize with a collection of dimensions. The rank of the tensor is the length of the
     /// collection.
     /// - Parameter dimensions: The shape dimensions.
-    @inlinable @inline(__always)
+    @inlinable
     public init<C: Collection>(_ dimensions: C) where C.Element == Int {
         self.dimensions = Array(dimensions)
     }
@@ -42,7 +42,7 @@ public struct TensorShape: ExpressibleByArrayLiteral {
     /// Initialize with an array literal representing the shape dimensions. The rank of the tensor
     /// is the number of dimensions.
     /// - Parameter dimensions: The shape dimensions.
-    @inlinable @inline(__always)
+    @inlinable
     public init(arrayLiteral elements: Int...) {
         self.init(elements)
     }
@@ -50,12 +50,12 @@ public struct TensorShape: ExpressibleByArrayLiteral {
     /// Initialize with variadic elements representing the shape dimensions. The rank of the tensor
     /// is the number of elements.
     /// - Parameter dimensions: The shape dimensions.
-    @inlinable @inline(__always)
+    @inlinable
     public init(_ elements: Int...) {
         self.init(elements)
     }
 
-    @inlinable @inline(__always)
+    @inlinable
     public init(repeating repeatedValue: Int, count: Int) {
         self.init(Array(repeating: repeatedValue, count: count))
     }
@@ -63,19 +63,13 @@ public struct TensorShape: ExpressibleByArrayLiteral {
     /// The rank of the shape (i.e. the number of dimensions).
     @inlinable
     public var rank: Int {
-        @inline(__always)
-        get {
-            return dimensions.count
-        }
+        return dimensions.count
     }
 
     /// The size of the shape as a contiguously stored array.
     @inlinable
     public var contiguousSize: Int {
-        @inline(__always)
-        get {
-            return dimensions.reduce(1, *)
-        }
+        return dimensions.reduce(1, *)
     }
 }
 
@@ -83,43 +77,29 @@ public extension TensorShape {
     /// The rank of the shape (i.e. the number of dimensions).
     @inlinable
     var count: Int {
-        @inline(__always)
-        get {
-            return dimensions.count
-        }
+        return dimensions.count
     }
 
     @inlinable
     var indices: Range<Int> {
-        @inline(__always)
-        get {
-            return dimensions.indices.lowerBound ..< dimensions.indices.upperBound
-        }
+        return dimensions.indices.lowerBound ..< dimensions.indices.upperBound
     }
 
     @inlinable
     var startIndex: Int {
-        @inline(__always)
-        get {
-            return dimensions.startIndex
-        }
+        return dimensions.startIndex
     }
 
     @inlinable
     var endIndex: Int {
-        @inline(__always)
-        get {
-            return dimensions.endIndex
-        }
+        return dimensions.endIndex
     }
 
     /// Access the size of the i-th dimension.
     /// - Parameter index: The index of a dimension.
     @inlinable
     subscript(index: Int) -> Int {
-        @inline(__always)
         _read { yield dimensions[index] }
-        @inline(__always)
         _modify { yield &dimensions[index] }
     }
 
@@ -127,19 +107,13 @@ public extension TensorShape {
     /// - Parameter index: The index of a dimension.
     @inlinable
     subscript(bounds: Range<Int>) -> TensorShape {
-        @inline(__always)
-        get {
-            return TensorShape(dimensions[bounds])
-        }
-        @inline(__always)
-        set {
-            dimensions[bounds] = ArraySlice(newValue.dimensions)
-        }
+        get { return TensorShape(dimensions[bounds]) }
+        set { dimensions[bounds] = ArraySlice(newValue.dimensions) }
     }
 }
 
 extension TensorShape: Equatable {
-    @inlinable @inline(__always)
+    @inlinable
     public static func == (lhs: TensorShape, rhs: TensorShape) -> Bool {
         return lhs.dimensions == rhs.dimensions
     }
diff --git a/Sources/TensorFlow/Initializers.swift b/Sources/TensorFlow/Initializers.swift
index bd39ce211..10e87b57f 100644
--- a/Sources/TensorFlow/Initializers.swift
+++ b/Sources/TensorFlow/Initializers.swift
@@ -19,7 +19,7 @@ public extension Tensor {
     /// - Parameters:
     ///   - shape: The dimensions of the tensor.
     ///   - repeatedValue: The scalar value to repeat.
-    @inlinable @inline(__always)
+    @inlinable
     @available(*, deprecated, renamed: "init(repeating:shape:)")
     init(shape: TensorShape, repeating repeatedValue: Scalar) {
         self.init(repeating: repeatedValue, shape: shape)
@@ -30,7 +30,7 @@ public extension Tensor {
     /// - Parameters:
     ///   - repeatedValue: The scalar value to repeat.
     ///   - shape: The dimensions of the tensor.
-    @inlinable @inline(__always)
+    @inlinable
     @differentiable(vjp: _vjpInit(repeating:shape:) where Scalar: TensorFlowFloatingPoint)
     init(repeating repeatedValue: Scalar, shape: TensorShape) {
         self = Raw.fill(
@@ -40,7 +40,7 @@ public extension Tensor {
 
     /// Creates a tensor by broadcasting the given scalar to a given rank with
     /// all dimensions being 1.
-    @inlinable @inline(__always)
+    @inlinable
     // @differentiable(where Scalar: TensorFlowFloatingPoint)
     init(broadcasting scalar: Scalar, rank: Int) {
         self = Tensor(scalar).reshaped(to: TensorShape(repeating: 1, count: rank))
@@ -49,7 +49,7 @@ public extension Tensor {
     /// Creates a tensor of shape `[4]` from a 4-tuple.
     /// - Note: This is intended for internal use, for example, to initialize a
     ///   tensor attribute from `convolved2D`'s `strides` argument.
-    @inlinable @inline(__always)
+    @inlinable
     internal init(_ scalars: (Scalar, Scalar, Scalar, Scalar)) {
         self.init([scalars.0, scalars.1, scalars.2, scalars.3])
     }
@@ -73,13 +73,13 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
 
 public extension Tensor where Scalar: Numeric {
     /// Perform an element-wise type conversion from a `Bool` tensor.
-    @inlinable @inline(__always)
+    @inlinable
     init(_ other: Tensor<Bool>) {
         self = Raw.cast(other)
     }
 
     /// Perform an element-wise conversion from another `Tensor`.
-    @inlinable @inline(__always)
+    @inlinable
     @differentiable(
         vjp: _vjpCast where Scalar: TensorFlowFloatingPoint, OtherScalar: TensorFlowFloatingPoint)
     init<OtherScalar: Numeric>(_ other: Tensor<OtherScalar>) {
@@ -102,7 +102,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
 
 public extension Tensor {
     /// Creates a tensor from an array of tensors (which may themselves be scalars).
-    @inlinable @inline(__always)
+    @inlinable
     @differentiable(vjp: _vjpInitElements where Scalar: TensorFlowFloatingPoint)
     init(_ elements: [Tensor]) {
         self = Raw.pack(elements)
@@ -136,7 +136,7 @@ public extension Tensor {
     ///   provided tensors.
     /// 
     /// - Returns: The stacked tensor.
-    @inlinable @inline(__always)
+    @inlinable
     @differentiable(vjp: _vjpStacking where Scalar: TensorFlowFloatingPoint)
     init(stacking tensors: [Tensor], alongAxis axis: Int = 0) {
         self = Raw.pack(tensors, axis: Int64(axis))
@@ -174,7 +174,7 @@ public extension Tensor {
     ///   provided tensors.
     /// 
     /// - Returns: The concatenated tensor.
-    @inlinable @inline(__always)
+    @inlinable
     @differentiable(vjp: _vjpConcatenating where Scalar: TensorFlowFloatingPoint)
     init(concatenating tensors: [Tensor], alongAxis axis: Int = 0) {
         precondition(tensors.count > 0)
@@ -225,7 +225,7 @@ public extension Tensor where Scalar: Numeric {
     /// Creates a tensor with all scalars set to zero.
     ///
     /// - Parameter shape: Shape of the tensor.
-    @inlinable @inline(__always)
+    @inlinable
     init(zeros shape: TensorShape) {
         self.init(repeating: 0, shape: shape)
     }
@@ -233,7 +233,7 @@ public extension Tensor where Scalar: Numeric {
     /// Creates a tensor with all scalars set to one.
     ///
     /// - Parameter shape: Shape of the tensor.
-    @inlinable @inline(__always)
+    @inlinable
     init(ones shape: TensorShape) {
         self.init(repeating: 1, shape: shape)
     }
@@ -242,7 +242,7 @@ public extension Tensor where Scalar: Numeric {
     /// tensor.
     ///
     /// - Parameter other: Tensor whose shape and data type to use.
-    @inlinable @inline(__always)
+    @inlinable
     init(zerosLike other: Tensor) {
         self = Raw.zerosLike(other)
     }
@@ -251,7 +251,7 @@ public extension Tensor where Scalar: Numeric {
     /// tensor.
     ///
     /// - Parameter other: Tensor whose shape and data type to use.
-    @inlinable @inline(__always)
+    @inlinable
     init(onesLike other: Tensor) {
         self = Raw.onesLike(other)
     }
@@ -266,7 +266,7 @@ public extension Tensor where Scalar: Numeric {
     ///     the resulting sequence.
     ///   - stride: The amount to step by with each iteration. `stride` must be
     ///     positive.
-    @inlinable @inline(__always)
+    @inlinable
     init(rangeFrom start: Scalar, to end: Scalar, stride: Scalar) {
         self = Raw.range(start: Tensor(start), limit: Tensor(end), delta: Tensor(stride))
     }
@@ -280,7 +280,7 @@ public extension Tensor where Scalar: Numeric {
     ///   - end: An end value to limit the sequence. `end` is never an element of the resulting
     ///     sequence.
     ///   - stride: The amount to step by with each iteration. `stride` must be positive.
-    @inlinable @inline(__always)
+    @inlinable
     init(rangeFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, stride: Tensor<Scalar>) {
         self = Raw.range(start: start, limit: end, delta: stride)
     }
@@ -312,7 +312,7 @@ public extension Tensor where Scalar: Numeric {
     ///   - offValue: A scalar defining the value at a location that is not
     ///     referred to by any index in `indices`.
     ///   - axis: The axis to fill. The default is `-1`, a new inner-most axis.
-    @inlinable @inline(__always)
+    @inlinable
     init(
         oneHotAtIndices indices: Tensor<Int32>,
         depth: Int,
diff --git a/Sources/TensorFlow/Operators/Comparison.swift b/Sources/TensorFlow/Operators/Comparison.swift
index 0ed6c7112..9c4334aae 100644
--- a/Sources/TensorFlow/Operators/Comparison.swift
+++ b/Sources/TensorFlow/Operators/Comparison.swift
@@ -21,81 +21,81 @@ infix operator .!=: ComparisonPrecedence
 
 public extension Tensor where Scalar: Numeric & Comparable {
     /// Computes `lhs < rhs` element-wise and returns a `Tensor` of Boolean /// scalars.
-    @inlinable @inline(__always)
+    @inlinable
     static func .< (lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.less(lhs, rhs)
     }
 
     /// Computes `lhs <= rhs` element-wise and returns a `Tensor` of Boolean scalars.
-    @inlinable @inline(__always)
+    @inlinable
     static func .<= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.lessEqual(lhs, rhs)
     }
 
     /// Computes `lhs > rhs` element-wise and returns a `Tensor` of Boolean scalars.
-    @inlinable @inline(__always)
+    @inlinable
     static func .> (lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.greater(lhs, rhs)
     }
 
     /// Computes `lhs >= rhs` element-wise and returns a `Tensor` of Boolean scalars.
-    @inlinable @inline(__always)
+    @inlinable
     static func .>= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.greaterEqual(lhs, rhs)
     }
 
     /// Computes `lhs < rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.<` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Raw.less(Tensor(lhs), rhs)
     }
 
     /// Computes `lhs <= rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.<=` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .<= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Raw.lessEqual(Tensor(lhs), rhs)
     }
 
     /// Computes `lhs > rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.>` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Raw.greater(Tensor(lhs), rhs)
     }
 
     /// Computes `lhs >= rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.>=` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .>= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Raw.greaterEqual(Tensor(lhs), rhs)
     }
 
     /// Computes `lhs < rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.<` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return Raw.less(lhs, Tensor(rhs))
     }
 
     /// Computes `lhs <= rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.<=` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .<= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return Raw.lessEqual(lhs, Tensor(rhs))
     }
 
     /// Computes `lhs > rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.>` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return Raw.greater(lhs, Tensor(rhs))
     }
 
     /// Computes `lhs >= rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.>=` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return Raw.greaterEqual(lhs, Tensor(rhs))
     }
@@ -104,28 +104,28 @@ public extension Tensor where Scalar: Numeric & Comparable {
 extension Tensor: Comparable where Scalar: Numeric & Comparable {
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically less than that of the second argument.
-    @inlinable @inline(__always)
+    @inlinable
     public static func < (lhs: Tensor, rhs: Tensor) -> Bool {
         return (lhs .< rhs).all()
     }
 
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically less than or equal to that of the second argument.
-    @inlinable @inline(__always)
+    @inlinable
     public static func <= (lhs: Tensor, rhs: Tensor) -> Bool {
         return (lhs .<= rhs).all()
     }
 
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically greater than that of the second argument.
-    @inlinable @inline(__always)
+    @inlinable
     public static func > (lhs: Tensor, rhs: Tensor) -> Bool {
         return (lhs .> rhs).all()
     }
 
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically greater than or equal to that of the second argument.
-    @inlinable @inline(__always)
+    @inlinable
     public static func >= (lhs: Tensor, rhs: Tensor) -> Bool {
         return (lhs .>= rhs).all()
     }
@@ -134,28 +134,28 @@ extension Tensor: Comparable where Scalar: Numeric & Comparable {
 public extension Tensor where Scalar: Numeric & Comparable {
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically less than that of the second argument.
-    @inlinable @inline(__always)
+    @inlinable
     static func < (lhs: Tensor, rhs: Scalar) -> Bool {
         return (lhs .< rhs).all()
     }
 
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically less than or equal to that of the second argument.
-    @inlinable @inline(__always)
+    @inlinable
     static func <= (lhs: Tensor, rhs: Scalar) -> Bool {
         return (lhs .<= rhs).all()
     }
 
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically greater than that of the second argument.
-    @inlinable @inline(__always)
+    @inlinable
     static func > (lhs: Tensor, rhs: Scalar) -> Bool {
         return (lhs .> rhs).all()
     }
 
     /// Returns a Boolean value indicating whether the value of the first argument is
     /// lexicographically greater than or equal to that of the second argument.
-    @inlinable @inline(__always)
+    @inlinable
     static func >= (lhs: Tensor, rhs: Scalar) -> Bool {
         return (lhs .>= rhs).all()
     }
@@ -164,28 +164,28 @@ public extension Tensor where Scalar: Numeric & Comparable {
 public extension Tensor where Scalar: Equatable {
     /// Computes `lhs != rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.==` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .== (lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.equal(lhs, rhs)
     }
 
     /// Computes `lhs != rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.!=` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .!= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool> {
         return Raw.notEqual(lhs, rhs)
     }
 
     /// Computes `lhs == rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.==` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .== (lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Tensor(lhs) .== rhs
     }
 
     /// Computes `lhs != rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.!=` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .!= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool> {
         return Tensor(lhs) .!= rhs
     }
@@ -193,14 +193,14 @@ public extension Tensor where Scalar: Equatable {
     /// Computes `lhs == rhs` element-wise and returns a `Tensor` of Boolean
     /// scalars.
     /// - Note: `.==` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .== (lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return lhs .== Tensor(rhs)
     }
 
     /// Computes `lhs != rhs` element-wise and returns a `Tensor` of Boolean scalars.
     /// - Note: `.!=` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool> {
         return lhs .!= Tensor(rhs)
     }
@@ -211,7 +211,7 @@ public extension Tensor where Scalar: Equatable {
 public extension Tensor where Scalar: FloatingPoint & Equatable {
     /// Returns a `Tensor` of Boolean values indicating whether the elements of `self` are
     /// approximately equal to those of `other`.
-    @inlinable @inline(__always)
+    @inlinable
     func elementsApproximatelyEqual(
         _ other: Tensor,
         tolerance: Double = 0.00001
@@ -223,7 +223,7 @@ public extension Tensor where Scalar: FloatingPoint & Equatable {
 public extension StringTensor {
     /// Computes `self == other` element-wise.
     /// - Note: `elementsEqual` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     func elementsEqual(_ other: StringTensor) -> Tensor<Bool> {
         return Raw.equal(self, other)
     }
diff --git a/Sources/TensorFlow/Operators/Dataset.swift b/Sources/TensorFlow/Operators/Dataset.swift
index 5f66e7c78..1338a384e 100644
--- a/Sources/TensorFlow/Operators/Dataset.swift
+++ b/Sources/TensorFlow/Operators/Dataset.swift
@@ -27,7 +27,7 @@
 ///
 // TODO: There's no support for TF's "global seed" yet, so we always use the default graph seed as 
 // the first seed. Need to investigate the best way to model TF's "global seed".
-@usableFromInline @inline(__always)
+@usableFromInline
 func _tensorSeeds(_ seed: Tensor<Int64>) -> (Tensor<Int64>, Tensor<Int64>) {
     return (Tensor(_defaultGraphSeed), seed)
 }
@@ -43,14 +43,14 @@ func _tensorSeeds(_ seed: Tensor<Int64>) -> (Tensor<Int64>, Tensor<Int64>) {
 public struct Dataset<Element: TensorGroup> {
     public let _handle: VariantHandle
 
-    @inlinable @inline(__always)
+    @inlinable
     public init(_handle: VariantHandle) {
         self._handle = _handle
     }
 }
 
 public extension Dataset {
-    @inlinable @inline(__always)
+    @inlinable
     init(randomSeed: Int64) {
         let (seed1, seed2) = _tensorSeeds(Tensor(randomSeed))
         self.init(_handle: Raw.experimentalRandomDataset(
@@ -63,7 +63,7 @@ public extension Dataset {
 
 public extension Dataset {
     /// Creates a dataset from a batch of elements as a tensor.
-    @inlinable @inline(__always)
+    @inlinable
     init(elements: Element) {
         self.init(_handle: Raw.tensorSliceDataset(
             components: [elements],
@@ -75,7 +75,7 @@ extension Dataset: Sequence {
     public typealias Iterator = DatasetIterator<Element>
 
     /// Returns an iterator over the elements of this dataset.
-    @inlinable @inline(__always)
+    @inlinable
     public func makeIterator() -> DatasetIterator<Element> {
         let resource = Raw.anonymousIterator(
             outputTypes: Element._typeList,
@@ -88,7 +88,7 @@ extension Dataset: Sequence {
 public extension Dataset {
     // Note that this Dataset API implementation uses an experimental tracing feature, which is not 
     // robust and does not have great diagnostics yet.
-    @inlinable @inline(__always)
+    @inlinable
     func map<ResultElement: TensorGroup>(
         _ transform: (Element) -> ResultElement
     ) -> Dataset<ResultElement> {
@@ -102,7 +102,7 @@ public extension Dataset {
             preserveCardinality: false))
     }
 
-    @inlinable @inline(__always)
+    @inlinable
     func map<ResultElement : TensorGroup>(
         parallelCallCount: Int,
         _ transform: (Element) -> ResultElement
@@ -119,10 +119,8 @@ public extension Dataset {
             preserveCardinality: false))
     }
 
-    @inlinable @inline(__always)
-    func filter(
-        _ isIncluded: (Element) -> Tensor<Bool>
-    ) -> Dataset {
+    @inlinable
+    func filter(_ isIncluded: (Element) -> Tensor<Bool>) -> Dataset {
         return Dataset(_handle: Raw.filterDataset(
             inputDataset: _handle,
             otherArguments: Tensor<Int32>(0),
@@ -133,7 +131,7 @@ public extension Dataset {
 }
 
 public extension Dataset {
-    @inlinable @inline(__always)
+    @inlinable
     func prefetched(count: Int) -> Dataset {
         return Dataset(_handle: Raw.prefetchDataset(
             inputDataset: _handle,
@@ -142,7 +140,7 @@ public extension Dataset {
             outputShapes: Element._unknownShapeList))
     }
 
-    @inlinable @inline(__always)
+    @inlinable
     func shuffled(
         sampleCount: Int,
         randomSeed: Int64,
@@ -159,7 +157,7 @@ public extension Dataset {
             outputShapes: Element._unknownShapeList))
     }
 
-    @inlinable @inline(__always)
+    @inlinable
     func batched(_ batchSize: Int) -> Dataset {
         return Dataset(_handle: Raw.batchDataset(
             inputDataset: _handle,
@@ -168,7 +166,7 @@ public extension Dataset {
             outputShapes: Element._unknownShapeList))
     }
 
-    @inlinable @inline(__always)
+    @inlinable
     func repeated(count: Int? = nil) -> Dataset {
         return Dataset(_handle: Raw.repeatDataset(
             inputDataset: _handle,
@@ -183,7 +181,7 @@ public extension Dataset {
 public struct DatasetIterator<Element: TensorGroup> {
     @usableFromInline let _handle: ResourceHandle
 
-    @usableFromInline @inline(__always)
+    @usableFromInline
     internal init(_handle: ResourceHandle) {
         self._handle = _handle
     }
@@ -191,7 +189,7 @@ public struct DatasetIterator<Element: TensorGroup> {
 
 extension DatasetIterator: IteratorProtocol {
     /// Advances to the next element and returns it, or `nil` if no next element exists.
-    @inlinable @inline(__always)
+    @inlinable
     public mutating func next() -> Element? {
         let optional = Raw.iteratorGetNextAsOptional(
             iterator: _handle,
@@ -220,7 +218,7 @@ public struct Zip2TensorGroup<T: TensorGroup, U: TensorGroup>: TensorGroup {
 }
 
 // TODO(SR-9156): This does not work in graph mode.
-@inlinable @inline(__always)
+@inlinable
 public func zip<T: TensorGroup, U: TensorGroup>(
     _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
 ) -> Dataset<Zip2TensorGroup<T, U>> {
diff --git a/Sources/TensorFlow/Operators/Math.swift b/Sources/TensorFlow/Operators/Math.swift
index f54a0cce9..c24b3ac21 100644
--- a/Sources/TensorFlow/Operators/Math.swift
+++ b/Sources/TensorFlow/Operators/Math.swift
@@ -69,28 +69,28 @@ extension Tensor: ShapedVectorNumeric where Scalar: Numeric {}
 
 public extension Tensor where Scalar: Numeric {
     /// Adds the scalar to every scalar of the tensor and produces the sum.
-    @inlinable @inline(__always)
+    @inlinable
     @differentiable(vjp: _vjpAdd(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
     static func + (lhs: Scalar, rhs: Tensor) -> Tensor {
         return Tensor(lhs) + rhs
     }
 
     /// Adds the scalar to every scalar of the tensor and produces the sum.
-    @inlinable @inline(__always)
+    @inlinable
     @differentiable(vjp: _vjpAdd(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
     static func + (lhs: Tensor, rhs: Scalar) -> Tensor {
         return lhs + Tensor(rhs)
     }
 
     /// Subtracts the scalar from every scalar of the tensor and produces the difference.
-    @inlinable @inline(__always)
+    @inlinable
     @differentiable(vjp: _vjpSubtract(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
     static func - (lhs: Scalar, rhs: Tensor) -> Tensor {
         return Tensor(lhs) - rhs
     }
 
     /// Subtracts the scalar from every scalar of the tensor and produces the difference
-    @inlinable @inline(__always)
+    @inlinable
     @differentiable(vjp: _vjpSubtract(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
     static func - (lhs: Tensor, rhs: Scalar) -> Tensor {
         return lhs - Tensor(rhs)
@@ -98,14 +98,14 @@ public extension Tensor where Scalar: Numeric {
 
     /// Adds two tensors and stores the result in the left-hand-side variable.
     /// - Note: `+=` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func += (lhs: inout Tensor, rhs: Tensor) {
         lhs = lhs + rhs
     }
 
     /// Adds the scalar to every scalar of the tensor and stores the result in the left-hand-side
     /// variable.
-    @inlinable @inline(__always)
+    @inlinable
     static func += (lhs: inout Tensor, rhs: Scalar) {
         lhs = lhs + rhs
     }
@@ -113,14 +113,14 @@ public extension Tensor where Scalar: Numeric {
     /// Subtracts the second tensor from the first and stores the result in the left-hand-side
     /// variable.
     /// - Note: `-=` supports broadcasting.
-    @inlinable @inline(__always)
+    @inlinable
     static func -= (lhs: inout Tensor, rhs: Tensor) {
         lhs = lhs - rhs
     }
 
     /// Subtracts the scalar from every scalar of the tensor and stores the result in the
     /// left-hand-side variable.
-    @inlinable @inline(__always)
+    @inlinable
     static func -= (lhs: inout Tensor, rhs: Scalar) {
         lhs = lhs - rhs
     }
@@ -850,7 +850,7 @@ public extension Tensor where Scalar == Bool {
     /// Returns `true` if all scalars are equal to `true`. Otherwise, returns `false`.
     // NOTE: This overload is necessary, otherwise `all()` would refer to the variadic method
     // `all(squeezingAxes:)` with zero indices.
-    @inlinable @inline(__always)
+    @inlinable
     func all() -> Bool {
         let axes = Tensor<Int32>(rangeFrom: 0, to: Int32(rank), stride: 1)
         return Raw.all(self, reductionIndices: axes).scalarized()
@@ -859,7 +859,7 @@ public extension Tensor where Scalar == Bool {
     /// Returns `true` if any scalars are equal to `true`. Otherwise, returns `false`.
     // NOTE: This overload is necessary, otherwise `any()` would refer to the variadic method
     // `any(squeezingAxes:)` with zero indices.
-    @inlinable @inline(__always)
+    @inlinable
     func any() -> Bool {
         let axes = Tensor<Int32>(rangeFrom: 0, to: Int32(rank), stride: 1)
         return Raw.any(self, reductionIndices: axes).scalarized()
@@ -869,7 +869,7 @@ public extension Tensor where Scalar == Bool {
     /// removed.
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
-    @inlinable @inline(__always)
+    @inlinable
     func all(squeezingAxes axes: Int...) -> Tensor {
         let axes = axes.map(Int32.init)
         return Raw.all(self, reductionIndices: Tensor<Int32>(axes), keepDims: false)
@@ -879,7 +879,7 @@ public extension Tensor where Scalar == Bool {
     /// removed.
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
-    @inlinable @inline(__always)
+    @inlinable
     func any(squeezingAxes axes: Int...) -> Tensor {
         let axes = axes.map(Int32.init)
         return Raw.any(self, reductionIndices: Tensor<Int32>(axes), keepDims: false)
@@ -889,7 +889,7 @@ public extension Tensor where Scalar == Bool {
     /// retained with value 1.
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
-    @inlinable @inline(__always)
+    @inlinable
     func all(alongAxes axes: Int...) -> Tensor {
         let axes = axes.map(Int32.init)
         return Raw.all(self, reductionIndices: Tensor<Int32>(axes), keepDims: true)
@@ -899,7 +899,7 @@ public extension Tensor where Scalar == Bool {
     /// dimensions are retained with value 1.
     /// - Parameter axes: The dimensions to reduce.
     /// - Precondition: Each value in `axes` must be in the range `-rank..<rank`.
-    @inlinable @inline(__always)
+    @inlinable
     func any(alongAxes axes: Int...) -> Tensor {
         let axes = axes.map(Int32.init)
         return Raw.any(self, reductionIndices: Tensor<Int32>(axes), keepDims: true)
@@ -1504,7 +1504,7 @@ public extension Tensor where Scalar: TensorFlowFloatingPoint {
 //===------------------------------------------------------------------------------------------===//
 
 /// Performs matrix multiplication with another tensor and produces the result.
-@inlinable @inline(__always)
+@inlinable
 @differentiable(vjp: _vjpMatmul(_:_:) where Scalar: TensorFlowFloatingPoint)
 public func matmul<Scalar: Numeric>(
     _ lhs: Tensor<Scalar>,
@@ -1534,7 +1534,7 @@ public extension Tensor where Scalar: Numeric {
     // After AD can differentiate generic methods, remove the custom VJP.
 
     /// Performs matrix multiplication between two tensors and produces the result.
-    @inlinable @inline(__always)
+    @inlinable
     @differentiable(vjp: _vjpMatmulOperator(lhs:rhs:) where Scalar: TensorFlowFloatingPoint)
     static func • (lhs: Tensor, rhs: Tensor) -> Tensor {
         return matmul(lhs, rhs)

From 5c076421d24ce6411b9a22b39ff8b3e637822f11 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 12 May 2019 11:54:05 -0400
Subject: [PATCH 28/55] Integrated changes from apple/swift#24723.

---
 Sources/TensorFlow/Core/Utilities.swift | 37 -------------------------
 1 file changed, 37 deletions(-)

diff --git a/Sources/TensorFlow/Core/Utilities.swift b/Sources/TensorFlow/Core/Utilities.swift
index 83358de14..e9fa78fb0 100644
--- a/Sources/TensorFlow/Core/Utilities.swift
+++ b/Sources/TensorFlow/Core/Utilities.swift
@@ -152,43 +152,6 @@ internal func writeContents(of buffer: UnsafePointer<TF_Buffer>, toFile path: St
 //===------------------------------------------------------------------------------------------===//
 // Unit Test Utilities
 //===------------------------------------------------------------------------------------------===//
-// TODO: Move this section to a unit-test only Swift module, once the google internal lit based test 
-// infra can handle importing additional Swift modules.
-
-/// This is a generic host-only op that hides the details of its impl in the SIL code. This makes 
-/// reading/writing SIL based compiler unit tests simple.
-@inlinable @inline(never)
-public func _hostOp<T>(_ x: T) {
-    print(x)
-}
-
-@inlinable @inline(never)
-public func _hostOp<Scalar>(_ x: Tensor<Scalar>) {
-    print(x)
-}
-
-@inlinable @inline(never)
-public func _hostOp<Scalar : TensorFlowScalar>(_ x: TensorHandle<Scalar>) {
-    print(Tensor(handle: x))
-}
-
-/// Some TPU ops (e.g. infeed/outfeed) require tensor shape info, which the APIs below can provide.
-///
-/// TODO: Remove these helper APIs, when we have a better shape inference/propagation design.
-@inlinable @inline(__always)
-public func _scalarTensorWithShape<Scalar: TensorFlowScalar>(
-    _ x: Tensor<Scalar>
-) -> Tensor<Scalar> {
-    return Raw.identity(x)
-}
-
-@inlinable @inline(__always)
-public func _addScalarTensorsWithShape<Scalar: TensorFlowNumeric>(
-    _ x: Tensor<Scalar>,
-    _ y: Tensor<Scalar>
-) -> Tensor<Scalar> {
-    return Raw.add(x, y)
-}
 
 // TODO: Consider revising the call sites where this is necessary to only need UnsafeMutablePointer 
 // to optional when it is the actual c-api call site.

From 14b884fa69c3c96bccf6d1009203f4f76448d132 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 12 May 2019 12:31:33 -0400
Subject: [PATCH 29/55] Minor edits.

---
 .../TensorFlow/Bindings/EagerExecution.swift  | 20 ++--
 .../Bindings/EagerExecution.swift.gyb         |  2 +-
 Sources/TensorFlow/Core/Helpers.swift         | 92 -------------------
 Sources/TensorFlow/Core/Runtime.swift         | 13 +--
 4 files changed, 12 insertions(+), 115 deletions(-)
 delete mode 100644 Sources/TensorFlow/Core/Helpers.swift

diff --git a/Sources/TensorFlow/Bindings/EagerExecution.swift b/Sources/TensorFlow/Bindings/EagerExecution.swift
index a7d13835f..9e3543a19 100644
--- a/Sources/TensorFlow/Bindings/EagerExecution.swift
+++ b/Sources/TensorFlow/Bindings/EagerExecution.swift
@@ -283,7 +283,7 @@ internal struct TFE_Op {
   }
 
   @inlinable
-  internal func execute<T0 : TensorArrayProtocol>(
+  internal func execute<T0: TensorArrayProtocol>(
     _ count0: Int
   ) -> (T0) {
     var count = Int32(count0)
@@ -303,7 +303,7 @@ internal struct TFE_Op {
   }
 
   @inlinable
-  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol>(
+  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int
   ) -> (T0, T1) {
@@ -326,7 +326,7 @@ internal struct TFE_Op {
   }
 
   @inlinable
-  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol>(
+  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
     _ count2: Int
@@ -352,7 +352,7 @@ internal struct TFE_Op {
   }
 
   @inlinable
-  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol>(
+  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
     _ count2: Int,
@@ -381,7 +381,7 @@ internal struct TFE_Op {
   }
 
   @inlinable
-  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol>(
+  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
     _ count2: Int,
@@ -413,7 +413,7 @@ internal struct TFE_Op {
   }
 
   @inlinable
-  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol>(
+  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
     _ count2: Int,
@@ -448,7 +448,7 @@ internal struct TFE_Op {
   }
 
   @inlinable
-  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol, T6 : TensorArrayProtocol>(
+  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
     _ count2: Int,
@@ -486,7 +486,7 @@ internal struct TFE_Op {
   }
 
   @inlinable
-  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol, T6 : TensorArrayProtocol, T7 : TensorArrayProtocol>(
+  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol, T7: TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
     _ count2: Int,
@@ -527,7 +527,7 @@ internal struct TFE_Op {
   }
 
   @inlinable
-  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol, T6 : TensorArrayProtocol, T7 : TensorArrayProtocol, T8 : TensorArrayProtocol>(
+  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol, T7: TensorArrayProtocol, T8: TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
     _ count2: Int,
@@ -571,7 +571,7 @@ internal struct TFE_Op {
   }
 
   @inlinable
-  internal func execute<T0 : TensorArrayProtocol, T1 : TensorArrayProtocol, T2 : TensorArrayProtocol, T3 : TensorArrayProtocol, T4 : TensorArrayProtocol, T5 : TensorArrayProtocol, T6 : TensorArrayProtocol, T7 : TensorArrayProtocol, T8 : TensorArrayProtocol, T9 : TensorArrayProtocol>(
+  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol, T7: TensorArrayProtocol, T8: TensorArrayProtocol, T9: TensorArrayProtocol>(
     _ count0: Int,
     _ count1: Int,
     _ count2: Int,
diff --git a/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb b/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
index 1eb586132..499eb0992 100644
--- a/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
+++ b/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
@@ -284,7 +284,7 @@ internal struct TFE_Op {
 
 %for n in range(1, 10 + 1):
   @inlinable
-  internal func execute<${", ".join(["T" + str(i) + " : TensorArrayProtocol" for i in range(n)])}>(
+  internal func execute<${", ".join(["T" + str(i) + ": TensorArrayProtocol" for i in range(n)])}>(
     ${",\n    ".join(["_ count" + str(i) + ": Int" for i in range(n)])}
   ) -> (${", ".join(["T" + str(i) for i in range(n)])}) {
     var count = ${" + ".join(["Int32(count" + str(i) + ")" for i in range(n)])}
diff --git a/Sources/TensorFlow/Core/Helpers.swift b/Sources/TensorFlow/Core/Helpers.swift
deleted file mode 100644
index 63e89f4c7..000000000
--- a/Sources/TensorFlow/Core/Helpers.swift
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
-//
-// 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.
-
-import CTensorFlow
-
-//===------------------------------------------------------------------------------------------===//
-// StringTensor
-//===------------------------------------------------------------------------------------------===//
-
-/// This compiler builtin is known by the partitioning pass, which recognizes it
-/// and promotes calls to it to being in graph when it can. This signature was
-/// designed to align with the requirements of the `Const` TensorFlow operation.
-@inlinable @inline(never)
-@_silgen_name("__tf_string_tensor_from_strings")
-public func _TFStringTensorFromStrings(_ scalars: [String], shape: [Int]) -> TensorHandle<String> {
-    let contiguousSize = shape.reduce(1, *)
-    precondition(scalars.count == contiguousSize, "The number of scalars does not match the shape.")
-
-    // utf8CString is null-terminated. TF APIs want the strings without null-terminators.
-    let cStrings = scalars.map { $0.utf8CString.dropLast() }
-
-    let tfEncodedSizes = cStrings.map { TF_StringEncodedSize($0.count) }
-
-    // Format information copied from tensorflow/c/c_api.h:
-    // The format for TF_STRING tensors is:
-    //   start_offset: array[uint64]
-    //   data:         byte[...]
-    //
-    //   The string length (as a varint), followed by the contents of the string
-    //   is encoded at data[start_offset[i]]].
-
-    // The size of the "start_offset" region.
-    let startOffsetsByteCount = scalars.count * MemoryLayout<UInt64>.stride
-
-    // The size of the "data" region.
-    let dataByteCount = tfEncodedSizes.reduce(0, +) * MemoryLayout<UInt8>.stride
-
-    return TensorHandle(
-        shape: shape,
-        byteCount: startOffsetsByteCount + dataByteCount,
-        bufferInitializer: { tensorBuffer in
-            // Initialize the "start_offset" region.
-            var startOffset: UInt64 = 0
-            var startOffsetAddr = tensorBuffer.bindMemory(to: UInt64.self, capacity: scalars.count)
-            for tfEncodedSize in tfEncodedSizes {
-                startOffsetAddr.initialize(to: startOffset)
-                startOffsetAddr = startOffsetAddr.advanced(by: 1)
-                startOffset = startOffset + UInt64(tfEncodedSize)
-            }
-
-            // Initialize the "data" region.
-            var dataAddr = tensorBuffer.advanced(by: startOffsetsByteCount)
-                .bindMemory(to: Int8.self, capacity: dataByteCount)
-            let status = TF_NewStatus()
-            for (cString, tfEncodedSize) in zip(cStrings, tfEncodedSizes) {
-                _ = cString.withUnsafeBufferPointer { buffer in
-                    TF_StringEncode(
-                        buffer.baseAddress,
-                        buffer.count,
-                        dataAddr,
-                        tfEncodedSize,
-                        status)
-                }
-                checkOk(status)
-                dataAddr = dataAddr.advanced(by: tfEncodedSize)
-            }
-            TF_DeleteStatus(status)
-        })
-}
-
-@inlinable @inline(never)
-@_silgen_name("__tf_string_tensor_from_string")
-public func _TFStringTensorFromString(_ scalar: String) -> TensorHandle<String> {
-    return _TFStringTensorFromStrings([scalar], shape: [])
-}
-
-@inlinable @inline(never)
-@_silgen_name("__tf_string_tensor_from_strings_1d")
-public func _TFStringTensorFromStrings1D(_ scalars: [String]) -> TensorHandle<String> {
-    return _TFStringTensorFromStrings(scalars, shape: [scalars.count])
-}
diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index cdda7157d..ba01536f4 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -19,20 +19,9 @@
 //
 // Design notes on TF eager based runtime:
 //
-// 1. A global context (`_ExecutionContext.global`) is used to manage all tensor
+// A global context (`_ExecutionContext.global`) is used to manage all tensor
 // computation and transfers.
 //
-// 2. When the tensor computation involves N device functions, run them in N
-// threads (but with the same execution/eager context). In addition, run the
-// host-side of sends/recvs in the main thread. These N + 1 threads form
-// "coroutines", and use sends/recvs mechanisms to communicate and unblock each
-// other's progress.
-// 2a) The sends/recvs mechanism between host and TF is the enqueue / dequeue
-// operations on TF (CPU-based) Fifo queues. Only tensor handles are transferred
-// in these enqueue / dequeue operations. For host to consume the content of the
-// tensor sent from TF, it uses TFE_TensorHandleResolve().
-// 2b) The sends/recvs mechanism between TF devices is the _Send / _Recv TF ops.
-//
 // Potential TODOs:
 // - Support async on platforms other than Linux and FreeBSD.
 // - Revisit the concurrency model and see if Dispatch can be built without

From c7ce282221412e31c9750a5ce3556eb3ec383ac1 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 12 May 2019 12:51:58 -0400
Subject: [PATCH 30/55] Bug fix.

---
 Sources/TensorFlow/Core/Tensor.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/TensorFlow/Core/Tensor.swift b/Sources/TensorFlow/Core/Tensor.swift
index f03f8a09f..9211d023a 100644
--- a/Sources/TensorFlow/Core/Tensor.swift
+++ b/Sources/TensorFlow/Core/Tensor.swift
@@ -108,7 +108,7 @@ public extension Tensor {
     /// otherwise.
     @inlinable
     var scalar: Scalar? {
-        return Scalar(self)
+        return handle.makeHostCopy().scalar
     }
 
     /// Reshape to scalar.

From 23b8f6fc3c789126cf3bbc9cd74f9c263ade8a0c Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Fri, 17 May 2019 17:04:13 -0400
Subject: [PATCH 31/55] Added a script for cloning the TensorFlow bindings.

---
 .gitignore                                    |     1 +
 .../TensorFlow/Bindings/EagerExecution.swift  |   620 -
 .../Bindings/EagerExecution.swift.gyb         |   309 -
 Sources/TensorFlow/Bindings/README.md         |    32 -
 .../TensorFlow/Bindings/RawOpsGenerated.swift | 35597 ----------------
 .../TensorFlow/Bindings/generate_wrappers.py  |   707 -
 clone_tensorflow_bindings.sh                  |     3 +
 7 files changed, 4 insertions(+), 37265 deletions(-)
 delete mode 100644 Sources/TensorFlow/Bindings/EagerExecution.swift
 delete mode 100644 Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
 delete mode 100644 Sources/TensorFlow/Bindings/README.md
 delete mode 100644 Sources/TensorFlow/Bindings/RawOpsGenerated.swift
 delete mode 100644 Sources/TensorFlow/Bindings/generate_wrappers.py
 create mode 100755 clone_tensorflow_bindings.sh

diff --git a/.gitignore b/.gitignore
index 567f66548..f68ac894b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,7 @@ xcuserdata
 DerivedData/
 *.xcodeproj
 *~
+Sources/TensorFlow/Bindings
 
 ### MacOS ###
 .DS_Store
diff --git a/Sources/TensorFlow/Bindings/EagerExecution.swift b/Sources/TensorFlow/Bindings/EagerExecution.swift
deleted file mode 100644
index 9e3543a19..000000000
--- a/Sources/TensorFlow/Bindings/EagerExecution.swift
+++ /dev/null
@@ -1,620 +0,0 @@
-// !!! THIS CODE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND !!!
-//
-// Copyright 2018-19 Google LLC
-//
-// 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
-//
-//     https://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.
-
-import CTensorFlow
-
-/// **WARNING:** After constructing a `TFE_Op`, any one of its `execute` methods must be called
-/// *exactly once*. If not called, then a memory leak is introduced due to the underlying TensorFlow
-/// eager op object not being freed. If called more than once, then a SEGFAULT may occur due to
-/// trying to execute a TensorFlow eager op that has already been freed.
-@usableFromInline
-internal struct TFE_Op {
-  @usableFromInline internal let status: CTFStatus
-  @usableFromInline internal let op: CTFEOp
-
-  @inlinable
-  internal init(_ name: String) {
-    self.status = TF_NewStatus()
-    self.op = TFE_NewOp(_ExecutionContext.global.eagerContext, name, status)
-  }
-
-  @inlinable
-  internal func addInput(_ inputHandle: _AnyTensorHandle) -> Int {
-    TFE_OpAddInput(op, inputHandle._cTensorHandle, status)
-    checkOk(status)
-    return 1
-  }
-
-  @inlinable
-  internal func addInput<Scalar: TensorFlowScalar>(_ input: Tensor<Scalar>) -> Int {
-    TFE_OpAddInput(op, input.handle._cTensorHandle, status)
-    checkOk(status)
-    return 1
-  }
-
-  @inlinable
-  internal func addInput(_ input: StringTensor) -> Int {
-    TFE_OpAddInput(op, input.handle._cTensorHandle, status)
-    checkOk(status)
-    return 1
-  }
-
-  @inlinable
-  internal func addInputList<T: TensorArrayProtocol>(_ input: T) -> Int {
-    let count = input._tensorHandleCount
-    var buffer = UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: Int(count))
-    defer { buffer.deallocate() }
-    let pointer = UnsafeMutablePointer<OpaquePointer?>(buffer.baseAddress)
-    input._unpackTensorHandles(into: buffer.baseAddress)
-    TFE_OpAddInputList(op, pointer, count, status)
-    // TODO: checkOk(status)
-    return Int(count)
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: Bool) {
-    TFE_OpSetAttrBool(op, name, value ? 1 : 0)
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: Int) {
-    TFE_OpSetAttrInt(op, name, Int64(value))
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: Int32) {
-    TFE_OpSetAttrInt(op, name, Int64(value))
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: Int64) {
-    TFE_OpSetAttrInt(op, name, value)
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: Float) {
-    TFE_OpSetAttrFloat(op, name, value)
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: Double) {
-    TFE_OpSetAttrFloat(op, name, Float(value))
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: String) {
-    value.utf8CString.withUnsafeBufferPointer { buffer in
-      // utf8CString is null-terminated; TFE_OpSetAttrString wants
-      // non-null-terminated.
-      TFE_OpSetAttrString(op, name, buffer.baseAddress, buffer.count - 1)
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: TensorDataType) {
-    TFE_OpSetAttrType(op, name, value._cDataType)
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: TensorShape) {
-    let dimensions: [Int64] = value.dimensions.map(Int64.init)
-    dimensions.withUnsafeBufferPointer { buffer in
-      TFE_OpSetAttrShape(op, name, buffer.baseAddress, Int32(buffer.count), status)
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: TensorShape?) {
-    guard let shape = value else {
-      TFE_OpSetAttrShape(op, name, nil, -1, status)
-      return
-    }
-    setAttr(name, shape)
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [Bool]) {
-    value.map({ $0 ? UInt8(1) : UInt8(0) }).withUnsafeBufferPointer { buffer in
-      TFE_OpSetAttrBoolList(op, name, buffer.baseAddress, Int32(buffer.count))
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [Int]) {
-    setAttr(name, value.map(Int64.init))
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [Int32]) {
-    setAttr(name, value.map(Int64.init))
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [Int64]) {
-    value.withUnsafeBufferPointer { buffer in
-      TFE_OpSetAttrIntList(op, name, buffer.baseAddress, Int32(buffer.count))
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [Float]) {
-    value.withUnsafeBufferPointer { buffer in
-      TFE_OpSetAttrFloatList(op, name, buffer.baseAddress, Int32(buffer.count))
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [Double]) {
-    setAttr(name, value.map(Float.init))
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [String]) {
-    // Collect all the strings' utf8 bytes into a single array so that we can
-    // address all the strings with a single
-    // `flattenedStringBytes.withUnsafeBufferPointer`.
-    var flattenedStringBytes: [CChar] = []
-    var lengths: [Int] = []
-    for string in value {
-      // Don't include the null-terminator because TFE_OpSetAttrStringList uses
-      // lengths instead of null-terminators.
-      let stringBytes = string.utf8CString.dropLast()
-      flattenedStringBytes.append(contentsOf: stringBytes)
-      lengths.append(stringBytes.count)
-    }
-
-    // Calculate the addresses of all the strings within our single buffer, and
-    // then call TFE_OpSetAttrStringList.
-    flattenedStringBytes.withUnsafeBufferPointer { flattenedStringBytesBuffer in
-      var stringAddrs: [UnsafeRawPointer?] = []
-      var currentStringAddr =
-        flattenedStringBytesBuffer.baseAddress.map(UnsafeRawPointer.init)
-      for length in lengths {
-        stringAddrs.append(currentStringAddr)
-        currentStringAddr = currentStringAddr?.advanced(by: length)
-      }
-
-      stringAddrs.withUnsafeBufferPointer { stringAddrsBuffer in
-        lengths.withUnsafeBufferPointer { lengthsBuffer in
-          TFE_OpSetAttrStringList(op, name, stringAddrsBuffer.baseAddress,
-            lengthsBuffer.baseAddress, Int32(value.count))
-        }
-      }
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [TensorDataType]) {
-    value.withUnsafeBufferPointer { buffer in
-      buffer.withMemoryRebound(to: TF_DataType.self) { reboundBuffer in
-        TFE_OpSetAttrTypeList(op, name, reboundBuffer.baseAddress, Int32(reboundBuffer.count))
-      }
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [TensorShape]) {
-    let flattenedDims = value.flatMap { $0.dimensions.map(Int64.init) }
-    let ranks = value.map { Int32($0.rank) }
-    flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
-      var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
-      var dims: [UnsafePointer<Int64>?] = []
-      for rank in ranks {
-        dims.append(dimsPtr)
-        if rank >= 0 {
-          dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
-        }
-      }
-      dims.withUnsafeMutableBufferPointer { dimsBuffer in
-        ranks.withUnsafeBufferPointer { ranksBuffer in
-          TFE_OpSetAttrShapeList(
-            op, name, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
-            Int32(ranksBuffer.count), status)
-        }
-      }
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [TensorShape?]) {
-    let flattenedDims = value.flatMap { (tensorShapeOpt) -> [Int64] in
-      if let tensorShape = tensorShapeOpt {
-        return tensorShape.dimensions.map(Int64.init)
-      }
-      return []
-    }
-    let ranks = value.map { shape in (shape?.rank).map(Int32.init) ?? -1 }
-    flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
-      var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
-      var dims: [UnsafePointer<Int64>?] = []
-      for rank in ranks {
-        dims.append(dimsPtr)
-        if rank >= 0 {
-          dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
-        }
-      }
-      dims.withUnsafeMutableBufferPointer { dimsBuffer in
-        ranks.withUnsafeBufferPointer { ranksBuffer in
-          TFE_OpSetAttrShapeList(
-            op, name, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
-            Int32(ranksBuffer.count), status)
-        }
-      }
-    }
-  }
-
-  @inlinable
-  internal func setAttr<In: TensorGroup, Out: TensorGroup>(_ name: String, _ value: (In) -> Out) {
-    _tffunc(value).utf8CString.withUnsafeBufferPointer { buffer in
-      // utf8CString is null-terminated; TFE_OpSetAttrFunctionName wants
-      // non-null-terminated.
-      TFE_OpSetAttrFunctionName(op, name, buffer.baseAddress, buffer.count - 1)
-    }
-  }
-
-  /// **WARNING:** After constructing a `TFE_Op`, any one of its `execute` methods must be called
-  /// *exactly once*. If not called, then a memory leak is introduced due to the underlying
-  /// TensorFlow eager op object not being freed. If called more than once, then a SEGFAULT may
-  /// occur due to trying to execute a TensorFlow eager op that has already been freed.
-
-  @inlinable
-  internal func execute() {
-    var count: Int32 = 0
-    var unused: CTensorHandle?
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, &unused, &count, status)
-    checkOk(status)
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-  }
-
-  @inlinable
-  internal func execute<T0: TensorArrayProtocol>(
-    _ count0: Int
-  ) -> (T0) {
-    var count = Int32(count0)
-    let buffer: UnsafeMutablePointer<CTensorHandle> =
-      UnsafeMutablePointer.allocate(capacity: Int(count))
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
-    checkOk(status)
-    let offset0 = Int32(0)
-    let result = (
-      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0))
-    buffer.deallocate()
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-    return result
-  }
-
-  @inlinable
-  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol>(
-    _ count0: Int,
-    _ count1: Int
-  ) -> (T0, T1) {
-    var count = Int32(count0) + Int32(count1)
-    let buffer: UnsafeMutablePointer<CTensorHandle> =
-      UnsafeMutablePointer.allocate(capacity: Int(count))
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
-    checkOk(status)
-    let offset0 = Int32(0)
-    let offset1 = offset0 + Int32(count0)
-    let result = (
-      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
-      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1))
-    buffer.deallocate()
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-    return result
-  }
-
-  @inlinable
-  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol>(
-    _ count0: Int,
-    _ count1: Int,
-    _ count2: Int
-  ) -> (T0, T1, T2) {
-    var count = Int32(count0) + Int32(count1) + Int32(count2)
-    let buffer: UnsafeMutablePointer<CTensorHandle> =
-      UnsafeMutablePointer.allocate(capacity: Int(count))
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
-    checkOk(status)
-    let offset0 = Int32(0)
-    let offset1 = offset0 + Int32(count0)
-    let offset2 = offset1 + Int32(count1)
-    let result = (
-      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
-      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
-      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2))
-    buffer.deallocate()
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-    return result
-  }
-
-  @inlinable
-  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol>(
-    _ count0: Int,
-    _ count1: Int,
-    _ count2: Int,
-    _ count3: Int
-  ) -> (T0, T1, T2, T3) {
-    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3)
-    let buffer: UnsafeMutablePointer<CTensorHandle> =
-      UnsafeMutablePointer.allocate(capacity: Int(count))
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
-    checkOk(status)
-    let offset0 = Int32(0)
-    let offset1 = offset0 + Int32(count0)
-    let offset2 = offset1 + Int32(count1)
-    let offset3 = offset2 + Int32(count2)
-    let result = (
-      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
-      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
-      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
-      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3))
-    buffer.deallocate()
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-    return result
-  }
-
-  @inlinable
-  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol>(
-    _ count0: Int,
-    _ count1: Int,
-    _ count2: Int,
-    _ count3: Int,
-    _ count4: Int
-  ) -> (T0, T1, T2, T3, T4) {
-    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3) + Int32(count4)
-    let buffer: UnsafeMutablePointer<CTensorHandle> =
-      UnsafeMutablePointer.allocate(capacity: Int(count))
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
-    checkOk(status)
-    let offset0 = Int32(0)
-    let offset1 = offset0 + Int32(count0)
-    let offset2 = offset1 + Int32(count1)
-    let offset3 = offset2 + Int32(count2)
-    let offset4 = offset3 + Int32(count3)
-    let result = (
-      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
-      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
-      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
-      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
-      T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4))
-    buffer.deallocate()
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-    return result
-  }
-
-  @inlinable
-  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol>(
-    _ count0: Int,
-    _ count1: Int,
-    _ count2: Int,
-    _ count3: Int,
-    _ count4: Int,
-    _ count5: Int
-  ) -> (T0, T1, T2, T3, T4, T5) {
-    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3) + Int32(count4) + Int32(count5)
-    let buffer: UnsafeMutablePointer<CTensorHandle> =
-      UnsafeMutablePointer.allocate(capacity: Int(count))
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
-    checkOk(status)
-    let offset0 = Int32(0)
-    let offset1 = offset0 + Int32(count0)
-    let offset2 = offset1 + Int32(count1)
-    let offset3 = offset2 + Int32(count2)
-    let offset4 = offset3 + Int32(count3)
-    let offset5 = offset4 + Int32(count4)
-    let result = (
-      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
-      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
-      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
-      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
-      T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
-      T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5))
-    buffer.deallocate()
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-    return result
-  }
-
-  @inlinable
-  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol>(
-    _ count0: Int,
-    _ count1: Int,
-    _ count2: Int,
-    _ count3: Int,
-    _ count4: Int,
-    _ count5: Int,
-    _ count6: Int
-  ) -> (T0, T1, T2, T3, T4, T5, T6) {
-    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3) + Int32(count4) + Int32(count5) + Int32(count6)
-    let buffer: UnsafeMutablePointer<CTensorHandle> =
-      UnsafeMutablePointer.allocate(capacity: Int(count))
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
-    checkOk(status)
-    let offset0 = Int32(0)
-    let offset1 = offset0 + Int32(count0)
-    let offset2 = offset1 + Int32(count1)
-    let offset3 = offset2 + Int32(count2)
-    let offset4 = offset3 + Int32(count3)
-    let offset5 = offset4 + Int32(count4)
-    let offset6 = offset5 + Int32(count5)
-    let result = (
-      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
-      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
-      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
-      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
-      T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
-      T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5),
-      T6.init(_owning: buffer.advanced(by: Int(offset6)), count: count6))
-    buffer.deallocate()
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-    return result
-  }
-
-  @inlinable
-  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol, T7: TensorArrayProtocol>(
-    _ count0: Int,
-    _ count1: Int,
-    _ count2: Int,
-    _ count3: Int,
-    _ count4: Int,
-    _ count5: Int,
-    _ count6: Int,
-    _ count7: Int
-  ) -> (T0, T1, T2, T3, T4, T5, T6, T7) {
-    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3) + Int32(count4) + Int32(count5) + Int32(count6) + Int32(count7)
-    let buffer: UnsafeMutablePointer<CTensorHandle> =
-      UnsafeMutablePointer.allocate(capacity: Int(count))
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
-    checkOk(status)
-    let offset0 = Int32(0)
-    let offset1 = offset0 + Int32(count0)
-    let offset2 = offset1 + Int32(count1)
-    let offset3 = offset2 + Int32(count2)
-    let offset4 = offset3 + Int32(count3)
-    let offset5 = offset4 + Int32(count4)
-    let offset6 = offset5 + Int32(count5)
-    let offset7 = offset6 + Int32(count6)
-    let result = (
-      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
-      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
-      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
-      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
-      T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
-      T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5),
-      T6.init(_owning: buffer.advanced(by: Int(offset6)), count: count6),
-      T7.init(_owning: buffer.advanced(by: Int(offset7)), count: count7))
-    buffer.deallocate()
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-    return result
-  }
-
-  @inlinable
-  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol, T7: TensorArrayProtocol, T8: TensorArrayProtocol>(
-    _ count0: Int,
-    _ count1: Int,
-    _ count2: Int,
-    _ count3: Int,
-    _ count4: Int,
-    _ count5: Int,
-    _ count6: Int,
-    _ count7: Int,
-    _ count8: Int
-  ) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8) {
-    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3) + Int32(count4) + Int32(count5) + Int32(count6) + Int32(count7) + Int32(count8)
-    let buffer: UnsafeMutablePointer<CTensorHandle> =
-      UnsafeMutablePointer.allocate(capacity: Int(count))
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
-    checkOk(status)
-    let offset0 = Int32(0)
-    let offset1 = offset0 + Int32(count0)
-    let offset2 = offset1 + Int32(count1)
-    let offset3 = offset2 + Int32(count2)
-    let offset4 = offset3 + Int32(count3)
-    let offset5 = offset4 + Int32(count4)
-    let offset6 = offset5 + Int32(count5)
-    let offset7 = offset6 + Int32(count6)
-    let offset8 = offset7 + Int32(count7)
-    let result = (
-      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
-      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
-      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
-      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
-      T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
-      T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5),
-      T6.init(_owning: buffer.advanced(by: Int(offset6)), count: count6),
-      T7.init(_owning: buffer.advanced(by: Int(offset7)), count: count7),
-      T8.init(_owning: buffer.advanced(by: Int(offset8)), count: count8))
-    buffer.deallocate()
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-    return result
-  }
-
-  @inlinable
-  internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol, T7: TensorArrayProtocol, T8: TensorArrayProtocol, T9: TensorArrayProtocol>(
-    _ count0: Int,
-    _ count1: Int,
-    _ count2: Int,
-    _ count3: Int,
-    _ count4: Int,
-    _ count5: Int,
-    _ count6: Int,
-    _ count7: Int,
-    _ count8: Int,
-    _ count9: Int
-  ) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {
-    var count = Int32(count0) + Int32(count1) + Int32(count2) + Int32(count3) + Int32(count4) + Int32(count5) + Int32(count6) + Int32(count7) + Int32(count8) + Int32(count9)
-    let buffer: UnsafeMutablePointer<CTensorHandle> =
-      UnsafeMutablePointer.allocate(capacity: Int(count))
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
-    checkOk(status)
-    let offset0 = Int32(0)
-    let offset1 = offset0 + Int32(count0)
-    let offset2 = offset1 + Int32(count1)
-    let offset3 = offset2 + Int32(count2)
-    let offset4 = offset3 + Int32(count3)
-    let offset5 = offset4 + Int32(count4)
-    let offset6 = offset5 + Int32(count5)
-    let offset7 = offset6 + Int32(count6)
-    let offset8 = offset7 + Int32(count7)
-    let offset9 = offset8 + Int32(count8)
-    let result = (
-      T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
-      T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
-      T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
-      T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
-      T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
-      T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5),
-      T6.init(_owning: buffer.advanced(by: Int(offset6)), count: count6),
-      T7.init(_owning: buffer.advanced(by: Int(offset7)), count: count7),
-      T8.init(_owning: buffer.advanced(by: Int(offset8)), count: count8),
-      T9.init(_owning: buffer.advanced(by: Int(offset9)), count: count9))
-    buffer.deallocate()
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-    return result
-  }
-
-}
diff --git a/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb b/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
deleted file mode 100644
index 499eb0992..000000000
--- a/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
+++ /dev/null
@@ -1,309 +0,0 @@
-// !!! THIS CODE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND !!!
-//
-// Copyright 2018-19 Google LLC
-//
-// 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
-//
-//     https://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.
-
-import CTensorFlow
-
-/// **WARNING:** After constructing a `TFE_Op`, any one of its `execute` methods must be called
-/// *exactly once*. If not called, then a memory leak is introduced due to the underlying TensorFlow
-/// eager op object not being freed. If called more than once, then a SEGFAULT may occur due to
-/// trying to execute a TensorFlow eager op that has already been freed.
-@usableFromInline
-internal struct TFE_Op {
-  @usableFromInline internal let status: CTFStatus
-  @usableFromInline internal let op: CTFEOp
-
-  @inlinable
-  internal init(_ name: String) {
-    self.status = TF_NewStatus()
-    self.op = TFE_NewOp(_ExecutionContext.global.eagerContext, name, status)
-  }
-
-  @inlinable
-  internal func addInput(_ inputHandle: _AnyTensorHandle) -> Int {
-    TFE_OpAddInput(op, inputHandle._cTensorHandle, status)
-    checkOk(status)
-    return 1
-  }
-
-  @inlinable
-  internal func addInput<Scalar: TensorFlowScalar>(_ input: Tensor<Scalar>) -> Int {
-    TFE_OpAddInput(op, input.handle._cTensorHandle, status)
-    checkOk(status)
-    return 1
-  }
-
-  @inlinable
-  internal func addInput(_ input: StringTensor) -> Int {
-    TFE_OpAddInput(op, input.handle._cTensorHandle, status)
-    checkOk(status)
-    return 1
-  }
-
-  @inlinable
-  internal func addInputList<T: TensorArrayProtocol>(_ input: T) -> Int {
-    let count = input._tensorHandleCount
-    var buffer = UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: Int(count))
-    defer { buffer.deallocate() }
-    let pointer = UnsafeMutablePointer<OpaquePointer?>(buffer.baseAddress)
-    input._unpackTensorHandles(into: buffer.baseAddress)
-    TFE_OpAddInputList(op, pointer, count, status)
-    // TODO: checkOk(status)
-    return Int(count)
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: Bool) {
-    TFE_OpSetAttrBool(op, name, value ? 1 : 0)
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: Int) {
-    TFE_OpSetAttrInt(op, name, Int64(value))
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: Int32) {
-    TFE_OpSetAttrInt(op, name, Int64(value))
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: Int64) {
-    TFE_OpSetAttrInt(op, name, value)
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: Float) {
-    TFE_OpSetAttrFloat(op, name, value)
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: Double) {
-    TFE_OpSetAttrFloat(op, name, Float(value))
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: String) {
-    value.utf8CString.withUnsafeBufferPointer { buffer in
-      // utf8CString is null-terminated; TFE_OpSetAttrString wants
-      // non-null-terminated.
-      TFE_OpSetAttrString(op, name, buffer.baseAddress, buffer.count - 1)
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: TensorDataType) {
-    TFE_OpSetAttrType(op, name, value._cDataType)
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: TensorShape) {
-    let dimensions: [Int64] = value.dimensions.map(Int64.init)
-    dimensions.withUnsafeBufferPointer { buffer in
-      TFE_OpSetAttrShape(op, name, buffer.baseAddress, Int32(buffer.count), status)
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: TensorShape?) {
-    guard let shape = value else {
-      TFE_OpSetAttrShape(op, name, nil, -1, status)
-      return
-    }
-    setAttr(name, shape)
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [Bool]) {
-    value.map({ $0 ? UInt8(1) : UInt8(0) }).withUnsafeBufferPointer { buffer in
-      TFE_OpSetAttrBoolList(op, name, buffer.baseAddress, Int32(buffer.count))
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [Int]) {
-    setAttr(name, value.map(Int64.init))
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [Int32]) {
-    setAttr(name, value.map(Int64.init))
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [Int64]) {
-    value.withUnsafeBufferPointer { buffer in
-      TFE_OpSetAttrIntList(op, name, buffer.baseAddress, Int32(buffer.count))
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [Float]) {
-    value.withUnsafeBufferPointer { buffer in
-      TFE_OpSetAttrFloatList(op, name, buffer.baseAddress, Int32(buffer.count))
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [Double]) {
-    setAttr(name, value.map(Float.init))
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [String]) {
-    // Collect all the strings' utf8 bytes into a single array so that we can
-    // address all the strings with a single
-    // `flattenedStringBytes.withUnsafeBufferPointer`.
-    var flattenedStringBytes: [CChar] = []
-    var lengths: [Int] = []
-    for string in value {
-      // Don't include the null-terminator because TFE_OpSetAttrStringList uses
-      // lengths instead of null-terminators.
-      let stringBytes = string.utf8CString.dropLast()
-      flattenedStringBytes.append(contentsOf: stringBytes)
-      lengths.append(stringBytes.count)
-    }
-
-    // Calculate the addresses of all the strings within our single buffer, and
-    // then call TFE_OpSetAttrStringList.
-    flattenedStringBytes.withUnsafeBufferPointer { flattenedStringBytesBuffer in
-      var stringAddrs: [UnsafeRawPointer?] = []
-      var currentStringAddr =
-        flattenedStringBytesBuffer.baseAddress.map(UnsafeRawPointer.init)
-      for length in lengths {
-        stringAddrs.append(currentStringAddr)
-        currentStringAddr = currentStringAddr?.advanced(by: length)
-      }
-
-      stringAddrs.withUnsafeBufferPointer { stringAddrsBuffer in
-        lengths.withUnsafeBufferPointer { lengthsBuffer in
-          TFE_OpSetAttrStringList(op, name, stringAddrsBuffer.baseAddress,
-            lengthsBuffer.baseAddress, Int32(value.count))
-        }
-      }
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [TensorDataType]) {
-    value.withUnsafeBufferPointer { buffer in
-      buffer.withMemoryRebound(to: TF_DataType.self) { reboundBuffer in
-        TFE_OpSetAttrTypeList(op, name, reboundBuffer.baseAddress, Int32(reboundBuffer.count))
-      }
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [TensorShape]) {
-    let flattenedDims = value.flatMap { $0.dimensions.map(Int64.init) }
-    let ranks = value.map { Int32($0.rank) }
-    flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
-      var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
-      var dims: [UnsafePointer<Int64>?] = []
-      for rank in ranks {
-        dims.append(dimsPtr)
-        if rank >= 0 {
-          dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
-        }
-      }
-      dims.withUnsafeMutableBufferPointer { dimsBuffer in
-        ranks.withUnsafeBufferPointer { ranksBuffer in
-          TFE_OpSetAttrShapeList(
-            op, name, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
-            Int32(ranksBuffer.count), status)
-        }
-      }
-    }
-  }
-
-  @inlinable
-  internal func setAttr(_ name: String, _ value: [TensorShape?]) {
-    let flattenedDims = value.flatMap { (tensorShapeOpt) -> [Int64] in
-      if let tensorShape = tensorShapeOpt {
-        return tensorShape.dimensions.map(Int64.init)
-      }
-      return []
-    }
-    let ranks = value.map { shape in (shape?.rank).map(Int32.init) ?? -1 }
-    flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
-      var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
-      var dims: [UnsafePointer<Int64>?] = []
-      for rank in ranks {
-        dims.append(dimsPtr)
-        if rank >= 0 {
-          dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
-        }
-      }
-      dims.withUnsafeMutableBufferPointer { dimsBuffer in
-        ranks.withUnsafeBufferPointer { ranksBuffer in
-          TFE_OpSetAttrShapeList(
-            op, name, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
-            Int32(ranksBuffer.count), status)
-        }
-      }
-    }
-  }
-
-  @inlinable
-  internal func setAttr<In: TensorGroup, Out: TensorGroup>(_ name: String, _ value: (In) -> Out) {
-    _tffunc(value).utf8CString.withUnsafeBufferPointer { buffer in
-      // utf8CString is null-terminated; TFE_OpSetAttrFunctionName wants
-      // non-null-terminated.
-      TFE_OpSetAttrFunctionName(op, name, buffer.baseAddress, buffer.count - 1)
-    }
-  }
-
-  /// **WARNING:** After constructing a `TFE_Op`, any one of its `execute` methods must be called
-  /// *exactly once*. If not called, then a memory leak is introduced due to the underlying
-  /// TensorFlow eager op object not being freed. If called more than once, then a SEGFAULT may
-  /// occur due to trying to execute a TensorFlow eager op that has already been freed.
-
-  @inlinable
-  internal func execute() {
-    var count: Int32 = 0
-    var unused: CTensorHandle?
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, &unused, &count, status)
-    checkOk(status)
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-  }
-
-%for n in range(1, 10 + 1):
-  @inlinable
-  internal func execute<${", ".join(["T" + str(i) + ": TensorArrayProtocol" for i in range(n)])}>(
-    ${",\n    ".join(["_ count" + str(i) + ": Int" for i in range(n)])}
-  ) -> (${", ".join(["T" + str(i) for i in range(n)])}) {
-    var count = ${" + ".join(["Int32(count" + str(i) + ")" for i in range(n)])}
-    let buffer: UnsafeMutablePointer<CTensorHandle> =
-      UnsafeMutablePointer.allocate(capacity: Int(count))
-    _TFCOpSetDeviceFromScope(op, status)
-    checkOk(status)
-    _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
-    checkOk(status)
-%for i in range(n):
-    let offset${i} = ${"Int32(0)" if i == 0 else "offset" + str(i - 1) + " + Int32(count" + str(i - 1) + ")"}
-%end
-    let result = (
-      ${",\n      ".join(["T" + str(i) + ".init(_owning: buffer.advanced(by: Int(offset" + str(i) + ")), count: count" + str(i) + ")" for i in range(n)])})
-    buffer.deallocate()
-    TFE_DeleteOp(op)
-    TF_DeleteStatus(status)
-    return result
-  }
-
-%end
-}
diff --git a/Sources/TensorFlow/Bindings/README.md b/Sources/TensorFlow/Bindings/README.md
deleted file mode 100644
index 339780be1..000000000
--- a/Sources/TensorFlow/Bindings/README.md
+++ /dev/null
@@ -1,32 +0,0 @@
-**Note:** This folder is a temporary solution that should be
-restructured later to make the op bindings generation
-smoother. However, it is acceptable as a temporary solution 
-since it should not be necessary to run the op bindings
-generation script frequently.
-
-# Swift for TensorFlow Ops Bindings
-
-This folder contains the TensorFlow op bindings.
-
-These bindings are automatically generated from TensorFlow ops
-specified either using ops registered to the TensorFlow runtime
-or via a protobuf file similar to
-[ops.pbtxt](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/ops/ops.pbtxt)
-in the main TensorFlow repo.
-
-## How to regenerate the bindings
-
-To regenerate the swift ops bindings, run the following command. Note
-that this will use the TensorFlow (1.9 or above) python package.
-
-``` shell
-python generate_wrappers.py --output_path=RawOpsGenerated.swift
-```
-
-Documentation gets automatically generated when adding a path to the
-`api_def` proto directory. This directory should contain per operator
-`api_def` protos with names like `api_def_OpName.pbtxt`.
-
-```shell
-python generate_wrappers.py --output_path=RawOpsGenerated.swift --api_def_path=/path/to/tensorflow/core/api_def/base_api
-```
diff --git a/Sources/TensorFlow/Bindings/RawOpsGenerated.swift b/Sources/TensorFlow/Bindings/RawOpsGenerated.swift
deleted file mode 100644
index 78b4728b7..000000000
--- a/Sources/TensorFlow/Bindings/RawOpsGenerated.swift
+++ /dev/null
@@ -1,35597 +0,0 @@
-// !!! THIS CODE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND !!!
-//
-// Copyright 2018-19 Google LLC
-//
-// 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
-//
-//     https://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.
-
-import CTensorFlow
-
-
-public enum Raw {
-
-static let generatedTensorFlowVersion = "1.14.1-dev20190421"
-static let generatedTensorFlowGitVersion = "v1.12.1-149-gd57b65578c"
-
-// @_frozen // SR-9739
-public enum A {
-  case apples
-  case oranges
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .apples: return "apples"
-      case .oranges: return "oranges"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum DataFormat {
-  case nchw
-  case nhwc
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .nchw: return "NCHW"
-      case .nhwc: return "NHWC"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum DataFormat1 {
-  case ncdhw
-  case ndhwc
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .ncdhw: return "NCDHW"
-      case .ndhwc: return "NDHWC"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum DataFormat4 {
-  case nchw
-  case nchwVectC
-  case nhwc
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .nchw: return "NCHW"
-      case .nchwVectC: return "NCHW_VECT_C"
-      case .nhwc: return "NHWC"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum DensityUnit {
-  case cm
-  case in_
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .cm: return "cm"
-      case .in_: return "in"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum Direction {
-  case bidirectional
-  case unidirectional
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .bidirectional: return "bidirectional"
-      case .unidirectional: return "unidirectional"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum Errors {
-  case ignore
-  case replace
-  case strict
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .ignore: return "ignore"
-      case .replace: return "replace"
-      case .strict: return "strict"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum FinalOp {
-  case div
-  case id
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .div: return "Div"
-      case .id: return "Id"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum Format {
-  case empty
-  case grayscale
-  case rgb
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .empty: return ""
-      case .grayscale: return "grayscale"
-      case .rgb: return "rgb"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum InputMode {
-  case autoSelect
-  case linearInput
-  case skipInput
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .autoSelect: return "auto_select"
-      case .linearInput: return "linear_input"
-      case .skipInput: return "skip_input"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum LossType {
-  case hingeLoss
-  case logisticLoss
-  case poissonLoss
-  case smoothHingeLoss
-  case squaredLoss
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .hingeLoss: return "hinge_loss"
-      case .logisticLoss: return "logistic_loss"
-      case .poissonLoss: return "poisson_loss"
-      case .smoothHingeLoss: return "smooth_hinge_loss"
-      case .squaredLoss: return "squared_loss"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum MergeOp {
-  case add
-  case max
-  case min
-  case mul
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .add: return "Add"
-      case .max: return "Max"
-      case .min: return "Min"
-      case .mul: return "Mul"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum Method {
-  case bilinear
-  case nearest
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .bilinear: return "bilinear"
-      case .nearest: return "nearest"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum Method3 {
-  case bilinear
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .bilinear: return "bilinear"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum Mode {
-  case minCombined
-  case minFirst
-  case scaled
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .minCombined: return "MIN_COMBINED"
-      case .minFirst: return "MIN_FIRST"
-      case .scaled: return "SCALED"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum Mode5 {
-  case reflect
-  case symmetric
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .reflect: return "REFLECT"
-      case .symmetric: return "SYMMETRIC"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum OutputEncoding {
-  case utf16Be
-  case utf32Be
-  case utf8
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .utf16Be: return "UTF-16-BE"
-      case .utf32Be: return "UTF-32-BE"
-      case .utf8: return "UTF-8"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum Padding {
-  case same
-  case valid
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .same: return "SAME"
-      case .valid: return "VALID"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum Padding2 {
-  case explicit
-  case same
-  case valid
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .explicit: return "EXPLICIT"
-      case .same: return "SAME"
-      case .valid: return "VALID"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum Reduction {
-  case max
-  case min
-  case prod
-  case sum
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .max: return "max"
-      case .min: return "min"
-      case .prod: return "prod"
-      case .sum: return "sum"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum RnnMode {
-  case gru
-  case lstm
-  case rnnRelu
-  case rnnTanh
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .gru: return "gru"
-      case .lstm: return "lstm"
-      case .rnnRelu: return "rnn_relu"
-      case .rnnTanh: return "rnn_tanh"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum RoundMode {
-  case halfToEven
-  case halfUp
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .halfToEven: return "HALF_TO_EVEN"
-      case .halfUp: return "HALF_UP"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum RoundMode6 {
-  case halfAwayFromZero
-  case halfToEven
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .halfAwayFromZero: return "HALF_AWAY_FROM_ZERO"
-      case .halfToEven: return "HALF_TO_EVEN"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum SplitType {
-  case inequality
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .inequality: return "inequality"
-      }
-    }
-  }
-}
-
-// @_frozen // SR-9739
-public enum Unit {
-  case byte
-  case utf8Char
-
-  @inlinable
-  var cName: String {
-    get {
-      switch self {
-      case .byte: return "BYTE"
-      case .utf8Char: return "UTF8_CHAR"
-      }
-    }
-  }
-}
-
-
-@inlinable
-public static func a(
-) -> Tensor<Float> {
-  let op = TFE_Op("A")
-  
-  return op.execute(Int(1))
-}
-
-/// Raise a exception to abort the process when called.
-///
-/// If exit_without_error is true, the process will exit normally,
-/// otherwise it will exit with a SIGABORT signal.
-///
-/// Returns nothing but an exception.
-///
-/// - Attr error_msg: A string which is the message associated with the exception.
-@inlinable
-public static func abort(
-  errorMsg: String,
-  exitWithoutError: Bool = false
-) {
-  let op = TFE_Op("Abort")
-  op.setAttr("error_msg", errorMsg)
-  op.setAttr("exit_without_error", exitWithoutError)
-  op.execute()
-}
-
-/// Computes the absolute value of a tensor.
-///
-/// Given a tensor `x`, this operation returns a tensor containing the absolute
-/// value of each element in `x`. For example, if x is an input element and y is
-/// an output element, this operation computes \\(y = |x|\\).
-@inlinable
-public static func abs<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Abs")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns the element-wise sum of a list of tensors.
-///
-/// `tf.accumulate_n_v2` performs the same operation as `tf.add_n`, but does not
-/// wait for all of its inputs to be ready before beginning to sum. This can
-/// save memory if inputs are ready at different times, since minimum temporary
-/// storage is proportional to the output size rather than the inputs size.
-///
-/// Unlike the original `accumulate_n`, `accumulate_n_v2` is differentiable.
-///
-/// Returns a `Tensor` of same shape and type as the elements of `inputs`.
-///
-/// - Parameter inputs: A list of `Tensor` objects, each with same shape and type.
-///
-/// - Attr shape: Shape of elements of `inputs`.
-@inlinable
-public static func accumulateNV2<T: Numeric & TensorFlowScalar>(
-  inputs: [Tensor<T>],
-  shape: TensorShape?
-) -> Tensor<T> {
-  let op = TFE_Op("AccumulateNV2")
-  op.setAttr("N", inputs.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("shape", shape)
-  let _ = op.addInputList(inputs)
-  return op.execute(Int(1))
-}
-
-/// Computes acos of x element-wise.
-@inlinable
-public static func acos<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Acos")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes inverse hyperbolic cosine of x element-wise.
-@inlinable
-public static func acosh<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Acosh")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns x + y element-wise.
-///
-/// *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func add<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Add")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns x + y element-wise.
-///
-/// *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func add(
-  _ x: StringTensor,
-  _ y: StringTensor
-) -> StringTensor {
-  let op = TFE_Op("Add")
-  op.setAttr("T", TensorDataType(TF_STRING))
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Add an `N`-minibatch `SparseTensor` to a `SparseTensorsMap`, return `N` handles.
-///
-/// A `SparseTensor` of rank `R` is represented by three tensors: `sparse_indices`,
-/// `sparse_values`, and `sparse_shape`, where
-///
-/// ```sparse_indices.shape[1] == sparse_shape.shape[0] == R```
-///
-/// An `N`-minibatch of `SparseTensor` objects is represented as a `SparseTensor`
-/// having a first `sparse_indices` column taking values between `[0, N)`, where
-/// the minibatch size `N == sparse_shape[0]`.
-///
-/// The input `SparseTensor` must have rank `R` greater than 1, and the first
-/// dimension is treated as the minibatch dimension.  Elements of the `SparseTensor`
-/// must be sorted in increasing order of this first dimension.  The stored
-/// `SparseTensor` objects pointed to by each row of the output `sparse_handles`
-/// will have rank `R-1`.
-///
-/// The `SparseTensor` values can then be read out as part of a minibatch by passing
-/// the given keys as vector elements to `TakeManySparseFromTensorsMap`.  To ensure
-/// the correct `SparseTensorsMap` is accessed, ensure that the same
-/// `container` and `shared_name` are passed to that Op.  If no `shared_name`
-/// is provided here, instead use the *name* of the Operation created by calling
-/// `AddManySparseToTensorsMap` as the `shared_name` passed to
-/// `TakeManySparseFromTensorsMap`.  Ensure the Operations are colocated.
-///
-/// - Parameters:
-///   - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
-///     `sparse_indices[:, 0]` must be ordered values in `[0, N)`.
-///   - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
-///   - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
-///     The minibatch size `N == sparse_shape[0]`.
-///
-/// - Attrs:
-///   - container: The container name for the `SparseTensorsMap` created by this op.
-///   - shared_name: The shared name for the `SparseTensorsMap` created by this op.
-///     If blank, the new Operation's unique name is used.
-///
-/// - Output sparse_handles: 1-D.  The handles of the `SparseTensor` now stored in the
-///   `SparseTensorsMap`.  Shape: `[N]`.
-@inlinable
-public static func addManySparseToTensorsMap<T: TensorFlowScalar>(
-  sparseIndices: Tensor<Int64>,
-  sparseValues: Tensor<T>,
-  sparseShape: Tensor<Int64>,
-  container: String,
-  sharedName: String
-) -> Tensor<Int64> {
-  let op = TFE_Op("AddManySparseToTensorsMap")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(sparseIndices)
-  let _ = op.addInput(sparseValues)
-  let _ = op.addInput(sparseShape)
-  return op.execute(Int(1))
-}
-
-/// Add all input tensors element wise.
-///
-/// - Parameter inputs: Must all be the same size and shape.
-@inlinable
-public static func addN<T: Numeric & TensorFlowScalar>(
-  inputs: [Tensor<T>]
-) -> Tensor<T> {
-  let op = TFE_Op("AddN")
-  op.setAttr("N", inputs.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInputList(inputs)
-  return op.execute(Int(1))
-}
-
-/// Add a `SparseTensor` to a `SparseTensorsMap` return its handle.
-///
-/// A `SparseTensor` is represented by three tensors: `sparse_indices`,
-/// `sparse_values`, and `sparse_shape`.
-///
-/// This operator takes the given `SparseTensor` and adds it to a container
-/// object (a `SparseTensorsMap`).  A unique key within this container is generated
-/// in the form of an `int64`, and this is the value that is returned.
-///
-/// The `SparseTensor` can then be read out as part of a minibatch by passing
-/// the key as a vector element to `TakeManySparseFromTensorsMap`.  To ensure
-/// the correct `SparseTensorsMap` is accessed, ensure that the same
-/// `container` and `shared_name` are passed to that Op.  If no `shared_name`
-/// is provided here, instead use the *name* of the Operation created by calling
-/// `AddSparseToTensorsMap` as the `shared_name` passed to
-/// `TakeManySparseFromTensorsMap`.  Ensure the Operations are colocated.
-///
-/// - Parameters:
-///   - sparse_indices: 2-D.  The `indices` of the `SparseTensor`.
-///   - sparse_values: 1-D.  The `values` of the `SparseTensor`.
-///   - sparse_shape: 1-D.  The `shape` of the `SparseTensor`.
-///
-/// - Attrs:
-///   - container: The container name for the `SparseTensorsMap` created by this op.
-///   - shared_name: The shared name for the `SparseTensorsMap` created by this op.
-///     If blank, the new Operation's unique name is used.
-///
-/// - Output sparse_handle: 0-D.  The handle of the `SparseTensor` now stored in the
-///   `SparseTensorsMap`.
-@inlinable
-public static func addSparseToTensorsMap<T: TensorFlowScalar>(
-  sparseIndices: Tensor<Int64>,
-  sparseValues: Tensor<T>,
-  sparseShape: Tensor<Int64>,
-  container: String,
-  sharedName: String
-) -> Tensor<Int64> {
-  let op = TFE_Op("AddSparseToTensorsMap")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(sparseIndices)
-  let _ = op.addInput(sparseValues)
-  let _ = op.addInput(sparseShape)
-  return op.execute(Int(1))
-}
-
-/// Returns x + y element-wise.
-///
-/// *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func addV2<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("AddV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Deprecated. Disallowed in GraphDef version >= 2.
-@inlinable
-public static func adjustContrast<T: Numeric & TensorFlowScalar>(
-  images: Tensor<T>,
-  contrastFactor: Tensor<Float>,
-  minValue: Tensor<Float>,
-  maxValue: Tensor<Float>
-) -> Tensor<Float> {
-  let op = TFE_Op("AdjustContrast")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(images)
-  let _ = op.addInput(contrastFactor)
-  let _ = op.addInput(minValue)
-  let _ = op.addInput(maxValue)
-  return op.execute(Int(1))
-}
-
-/// Adjust the contrast of one or more images.
-///
-/// `images` is a tensor of at least 3 dimensions.  The last 3 dimensions are
-/// interpreted as `[height, width, channels]`.  The other dimensions only
-/// represent a collection of images, such as `[batch, height, width, channels].`
-///
-/// Contrast is adjusted independently for each channel of each image.
-///
-/// For each channel, the Op first computes the mean of the image pixels in the
-/// channel and then adjusts each component of each pixel to
-/// `(x - mean) * contrast_factor + mean`.
-///
-/// - Parameters:
-///   - images: Images to adjust.  At least 3-D.
-///   - contrast_factor: A float multiplier for adjusting contrast.
-///
-/// - Output output: The contrast-adjusted image or images.
-@inlinable
-public static func adjustContrastv2<T: FloatingPoint & TensorFlowScalar>(
-  images: Tensor<T>,
-  contrastFactor: Tensor<Float>
-) -> Tensor<T> {
-  let op = TFE_Op("AdjustContrastv2")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(images)
-  let _ = op.addInput(contrastFactor)
-  return op.execute(Int(1))
-}
-
-/// Adjust the hue of one or more images.
-///
-/// `images` is a tensor of at least 3 dimensions.  The last dimension is
-/// interpretted as channels, and must be three.
-///
-/// The input image is considered in the RGB colorspace. Conceptually, the RGB
-/// colors are first mapped into HSV. A delta is then applied all the hue values,
-/// and then remapped back to RGB colorspace.
-///
-/// - Parameters:
-///   - images: Images to adjust.  At least 3-D.
-///   - delta: A float delta to add to the hue.
-///
-/// - Output output: The hue-adjusted image or images.
-@inlinable
-public static func adjustHue<T: FloatingPoint & TensorFlowScalar>(
-  images: Tensor<T>,
-  delta: Tensor<Float>
-) -> Tensor<T> {
-  let op = TFE_Op("AdjustHue")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(images)
-  let _ = op.addInput(delta)
-  return op.execute(Int(1))
-}
-
-/// Adjust the saturation of one or more images.
-///
-/// `images` is a tensor of at least 3 dimensions.  The last dimension is
-/// interpretted as channels, and must be three.
-///
-/// The input image is considered in the RGB colorspace. Conceptually, the RGB
-/// colors are first mapped into HSV. A scale is then applied all the saturation
-/// values, and then remapped back to RGB colorspace.
-///
-/// - Parameters:
-///   - images: Images to adjust.  At least 3-D.
-///   - scale: A float scale to add to the saturation.
-///
-/// - Output output: The hue-adjusted image or images.
-@inlinable
-public static func adjustSaturation<T: FloatingPoint & TensorFlowScalar>(
-  images: Tensor<T>,
-  scale: Tensor<Float>
-) -> Tensor<T> {
-  let op = TFE_Op("AdjustSaturation")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(images)
-  let _ = op.addInput(scale)
-  return op.execute(Int(1))
-}
-
-/// Computes the "logical and" of elements across dimensions of a tensor.
-///
-/// Reduces `input` along the dimensions given in `axis`. Unless
-/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-/// `axis`. If `keep_dims` is true, the reduced dimensions are
-/// retained with length 1.
-///
-/// - Parameters:
-///   - input: The tensor to reduce.
-///   - reduction_indices: The dimensions to reduce. Must be in the range
-///     `[-rank(input), rank(input))`.
-///
-/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-///
-/// - Output output: The reduced tensor.
-@inlinable
-public static func all<Tidx: BinaryInteger & TensorFlowScalar>(
-  _ input: Tensor<Bool>,
-  reductionIndices: Tensor<Tidx>,
-  keepDims: Bool = false
-) -> Tensor<Bool> {
-  let op = TFE_Op("All")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(reductionIndices)
-  return op.execute(Int(1))
-}
-
-/// Generates labels for candidate sampling with a learned unigram distribution.
-///
-/// See explanations of candidate sampling and the data formats at
-/// go/candidate-sampling.
-///
-/// For each batch, this op picks a single set of sampled candidate labels.
-///
-/// The advantages of sampling candidates per-batch are simplicity and the
-/// possibility of efficient dense matrix multiplication. The disadvantage is that
-/// the sampled candidates must be chosen independently of the context and of the
-/// true labels.
-///
-/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
-///   IDs of the num_true target_classes in the corresponding original label.
-///
-/// - Attrs:
-///   - num_true: Number of true labels per context.
-///   - num_sampled: Number of candidates to produce.
-///   - unique: If unique is true, we sample with rejection, so that all sampled
-///     candidates in a batch are unique. This requires some approximation to
-///     estimate the post-rejection sampling probabilities.
-///   - seed: If either seed or seed2 are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: An second seed to avoid seed collision.
-///
-/// - Outputs:
-///   - sampled_candidates: A vector of length num_sampled, in which each element is
-///     the ID of a sampled candidate.
-///   - true_expected_count: A batch_size * num_true matrix, representing
-///     the number of times each candidate is expected to occur in a batch
-///     of sampled candidates. If unique=true, then this is a probability.
-///   - sampled_expected_count: A vector of length num_sampled, for each sampled
-///     candidate representing the number of times the candidate is expected
-///     to occur in a batch of sampled candidates.  If unique=true, then this is a
-///     probability.
-@inlinable
-public static func allCandidateSampler(
-  trueClasses: Tensor<Int64>,
-  numTrue: Int64,
-  numSampled: Int64,
-  unique: Bool,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
-  let op = TFE_Op("AllCandidateSampler")
-  op.setAttr("num_true", numTrue)
-  op.setAttr("num_sampled", numSampled)
-  op.setAttr("unique", unique)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(trueClasses)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// An Op to exchange data across TPU replicas.
-///
-/// On each replica, the input is split into `split_count` blocks along
-/// `split_dimension` and send to the other replicas given group_assignment. After
-/// receiving `split_count` - 1 blocks from other replicas, we concatenate the
-/// blocks along `concat_dimension` as the output.
-///
-/// For example, suppose there are 2 TPU replicas:
-/// replica 0 receives input: `[[A, B]]`
-/// replica 1 receives input: `[[C, D]]`
-///
-/// group_assignment=`[[0, 1]]`
-/// concat_dimension=0
-/// split_dimension=1
-/// split_count=2
-///
-/// replica 0's output: `[[A], [C]]`
-/// replica 1's output: `[[B], [D]]`
-///
-/// - Parameters:
-///   - input: The local input to the sum.
-///   - group_assignment: An int32 tensor with shape
-///     [num_groups, num_replicas_per_group]. `group_assignment[i]` represents the
-///     replica ids in the ith subgroup.
-///
-/// - Attrs:
-///   - T: The type of elements to be exchanged.
-///   - concat_dimension: The dimension number to concatenate.
-///   - split_dimension: The dimension number to split.
-///   - split_count: The number of splits, this number must equal to the sub-group
-///     size(group_assignment.get_shape()[1])
-///
-/// - Output output: The exchanged result.
-@inlinable
-public static func allToAll<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  groupAssignment: Tensor<Int32>,
-  concatDimension: Int64,
-  splitDimension: Int64,
-  splitCount: Int64
-) -> Tensor<T> {
-  let op = TFE_Op("AllToAll")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("concat_dimension", concatDimension)
-  op.setAttr("split_dimension", splitDimension)
-  op.setAttr("split_count", splitCount)
-  let _ = op.addInput(input)
-  let _ = op.addInput(groupAssignment)
-  return op.execute(Int(1))
-}
-
-/// Returns the argument of a complex number.
-///
-/// Given a tensor `input` of complex numbers, this operation returns a tensor of
-/// type `float` that is the argument of each element in `input`. All elements in
-/// `input` must be complex numbers of the form \\(a + bj\\), where *a*
-/// is the real part and *b* is the imaginary part.
-///
-/// The argument returned by this operation is of the form \\(atan2(b, a)\\).
-///
-/// For example:
-///
-/// ```
-/// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
-/// tf.angle(input) ==> [2.0132, 1.056]
-/// ```
-///
-/// @compatibility(numpy)
-/// Equivalent to np.angle.
-/// @end_compatibility
-@inlinable
-public static func angle<
-    T: TensorFlowScalar,
-    Tout: FloatingPoint & TensorFlowScalar
->(
-  _ input: Tensor<T>
-) -> Tensor<Tout> {
-  let op = TFE_Op("Angle")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tout", Tout.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// A container for an iterator resource.
-///
-/// - Output handle: A handle to the iterator that can be passed to a "MakeIterator" or
-///   "IteratorGetNext" op. In contrast to Iterator, AnonymousIterator prevents
-///   resource sharing by name, and does not keep a reference to the resource
-///   container.
-@inlinable
-public static func anonymousIterator(
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> ResourceHandle {
-  let op = TFE_Op("AnonymousIterator")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  return op.execute(Int(1))
-}
-
-/// A container for an iterator resource.
-///
-/// - Outputs:
-///   - handle: A handle to the iterator that can be passed to a "MakeIterator" or
-///     "IteratorGetNext" op. In contrast to Iterator, AnonymousIterator prevents
-///     resource sharing by name, and does not keep a reference to the resource
-///     container.
-///   - deleter: A variant deleter that should be passed into the op that deletes the iterator.
-@inlinable
-public static func anonymousIteratorV2(
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> (handle: ResourceHandle, deleter: VariantHandle) {
-  let op = TFE_Op("AnonymousIteratorV2")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Computes the "logical or" of elements across dimensions of a tensor.
-///
-/// Reduces `input` along the dimensions given in `axis`. Unless
-/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-/// `axis`. If `keep_dims` is true, the reduced dimensions are
-/// retained with length 1.
-///
-/// - Parameters:
-///   - input: The tensor to reduce.
-///   - reduction_indices: The dimensions to reduce. Must be in the range
-///     `[-rank(input), rank(input))`.
-///
-/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-///
-/// - Output output: The reduced tensor.
-@inlinable
-public static func any<Tidx: BinaryInteger & TensorFlowScalar>(
-  _ input: Tensor<Bool>,
-  reductionIndices: Tensor<Tidx>,
-  keepDims: Bool = false
-) -> Tensor<Bool> {
-  let op = TFE_Op("Any")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(reductionIndices)
-  return op.execute(Int(1))
-}
-
-/// Returns the truth value of abs(x-y) < tolerance element-wise.
-@inlinable
-public static func approximateEqual<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>,
-  tolerance: Double = 1e-05
-) -> Tensor<Bool> {
-  let op = TFE_Op("ApproximateEqual")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("tolerance", tolerance)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns the index with the largest value across dimensions of a tensor.
-///
-/// Note that in case of ties the identity of the return value is not guaranteed.
-///
-/// Usage:
-///   ```python
-///   import tensorflow as tf
-///   a = [1, 10, 26.9, 2.8, 166.32, 62.3]
-///   b = tf.math.argmax(input = a)
-///   c = tf.keras.backend.eval(b)  
-///   # c = 4
-///   # here a[4] = 166.32 which is the largest element of a across axis 0
-///   ```
-///
-/// - Parameter dimension: int32 or int64, must be in the range `[-rank(input), rank(input))`.
-///   Describes which dimension of the input Tensor to reduce across. For vectors,
-///   use dimension = 0.
-@inlinable
-public static func argMax<
-    T: Numeric & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar,
-    OutputType: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  dimension: Tensor<Tidx>
-) -> Tensor<OutputType> {
-  let op = TFE_Op("ArgMax")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  op.setAttr("output_type", OutputType.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(dimension)
-  return op.execute(Int(1))
-}
-
-/// Returns the index with the smallest value across dimensions of a tensor.
-///
-/// Note that in case of ties the identity of the return value is not guaranteed.
-///
-/// Usage:
-///   ```python
-///   import tensorflow as tf
-///   a = [1, 10, 26.9, 2.8, 166.32, 62.3]
-///   b = tf.math.argmin(input = a)
-///   c = tf.keras.backend.eval(b)  
-///   # c = 0
-///   # here a[0] = 1 which is the smallest element of a across axis 0
-///   ```
-///
-/// - Parameter dimension: int32 or int64, must be in the range `[-rank(input), rank(input))`.
-///   Describes which dimension of the input Tensor to reduce across. For vectors,
-///   use dimension = 0.
-@inlinable
-public static func argMin<
-    T: Numeric & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar,
-    OutputType: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  dimension: Tensor<Tidx>
-) -> Tensor<OutputType> {
-  let op = TFE_Op("ArgMin")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  op.setAttr("output_type", OutputType.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(dimension)
-  return op.execute(Int(1))
-}
-
-/// Converts each entry in the given tensor to strings.  Supports many numeric
-///
-/// types and boolean.
-///
-/// - Attrs:
-///   - precision: The post-decimal precision to use for floating point numbers.
-///     Only used if precision > -1.
-///   - scientific: Use scientific notation for floating point numbers.
-///   - shortest: Use shortest representation (either scientific or standard) for
-///     floating point numbers.
-///   - width: Pad pre-decimal numbers to this width.
-///     Applies to both floating point and integer numbers.
-///     Only used if width > -1.
-///   - fill: The value to pad if width > -1.  If empty, pads with spaces.
-///     Another typical value is '0'.  String cannot be longer than 1 character.
-@inlinable
-public static func asString<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  precision: Int64 = -1,
-  scientific: Bool = false,
-  shortest: Bool = false,
-  width: Int64 = -1,
-  fill: String
-) -> StringTensor {
-  let op = TFE_Op("AsString")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("precision", precision)
-  op.setAttr("scientific", scientific)
-  op.setAttr("shortest", shortest)
-  op.setAttr("width", width)
-  op.setAttr("fill", fill)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Computes the trignometric inverse sine of x element-wise.
-///
-/// The `tf.math.asin` operation returns the inverse of `tf.math.sin`, such that
-/// if `y = tf.math.sin(x)` then, `x = tf.math.asin(y)`.
-///
-/// **Note**: The output of `tf.math.asin` will lie within the invertible range 
-/// of sine, i.e [-pi/2, pi/2].
-///
-/// For example:
-///
-/// ```python
-/// # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)]
-/// x = tf.constant([1.047, 0.785])
-/// y = tf.math.sin(x) # [0.8659266, 0.7068252]
-///
-/// tf.math.asin(y) # [1.047, 0.785] = x
-/// ```
-///
-@inlinable
-public static func asin<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Asin")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes inverse hyperbolic sine of x element-wise.
-@inlinable
-public static func asinh<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Asinh")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Asserts that the given condition is true.
-///
-/// If `condition` evaluates to false, print the list of tensors in `data`.
-/// `summarize` determines how many entries of the tensors to print.
-///
-/// - Parameters:
-///   - condition: The condition to evaluate.
-///   - data: The tensors to print out when condition is false.
-///
-/// - Attr summarize: Print this many entries of each tensor.
-@inlinable
-public static func assert<T: TensorArrayProtocol>(
-  condition: Tensor<Bool>,
-  data: T,
-  summarize: Int64 = 3
-) {
-  let op = TFE_Op("Assert")
-  op.setAttr("T", data._typeList)
-  op.setAttr("summarize", summarize)
-  let _ = op.addInput(condition)
-  let _ = op.addInputList(data)
-  op.execute()
-}
-
-/// Adds a value to the current value of a variable.
-///
-/// Any ReadVariableOp with a control dependency on this op is guaranteed to
-/// see the incremented value or a subsequent newer one.
-///
-/// - Parameters:
-///   - resource: handle to the resource in which to store the variable.
-///   - value: the value by which the variable will be incremented.
-///
-/// - Attr dtype: the dtype of the value.
-@inlinable
-public static func assignAddVariableOp<Dtype: TensorFlowScalar>(
-  resource: ResourceHandle,
-  value: Tensor<Dtype>
-) {
-  let op = TFE_Op("AssignAddVariableOp")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(value)
-  op.execute()
-}
-
-/// Subtracts a value from the current value of a variable.
-///
-/// Any ReadVariableOp with a control dependency on this op is guaranteed to
-/// see the decremented value or a subsequent newer one.
-///
-/// - Parameters:
-///   - resource: handle to the resource in which to store the variable.
-///   - value: the value by which the variable will be incremented.
-///
-/// - Attr dtype: the dtype of the value.
-@inlinable
-public static func assignSubVariableOp<Dtype: TensorFlowScalar>(
-  resource: ResourceHandle,
-  value: Tensor<Dtype>
-) {
-  let op = TFE_Op("AssignSubVariableOp")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(value)
-  op.execute()
-}
-
-/// Assigns a new value to a variable.
-///
-/// Any ReadVariableOp with a control dependency on this op is guaranteed to return
-/// this value or a subsequent newer value of the variable.
-///
-/// - Parameters:
-///   - resource: handle to the resource in which to store the variable.
-///   - value: the value to set the new tensor to use.
-///
-/// - Attr dtype: the dtype of the value.
-@inlinable
-public static func assignVariableOp<Dtype: TensorFlowScalar>(
-  resource: ResourceHandle,
-  value: Tensor<Dtype>
-) {
-  let op = TFE_Op("AssignVariableOp")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(value)
-  op.execute()
-}
-
-/// Computes the trignometric inverse tangent of x element-wise.
-///
-/// The `tf.math.atan` operation returns the inverse of `tf.math.tan`, such that
-/// if `y = tf.math.tan(x)` then, `x = tf.math.atan(y)`.
-///
-/// **Note**: The output of `tf.math.atan` will lie within the invertible range 
-/// of tan, i.e (-pi/2, pi/2).
-///
-/// For example:
-///
-/// ```python
-/// # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)]
-/// x = tf.constant([1.047, 0.785])
-/// y = tf.math.tan(x) # [1.731261, 0.99920404]
-///
-/// tf.math.atan(y) # [1.047, 0.785] = x
-/// ```
-///
-@inlinable
-public static func atan<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Atan")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes arctangent of `y/x` element-wise, respecting signs of the arguments.
-///
-/// This is the angle \( \theta \in [-\pi, \pi] \) such that
-/// \[ x = r \cos(\theta) \]
-/// and
-/// \[ y = r \sin(\theta) \]
-/// where \(r = \sqrt(x^2 + y^2) \).
-@inlinable
-public static func atan2<T: FloatingPoint & TensorFlowScalar>(
-  _ y: Tensor<T>,
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Atan2")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(y)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes inverse hyperbolic tangent of x element-wise.
-@inlinable
-public static func atanh<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Atanh")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func attr(
-  _ a: Int64
-) {
-  let op = TFE_Op("Attr")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrBool(
-  _ a: Bool
-) {
-  let op = TFE_Op("AttrBool")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrBoolList(
-  _ a: [Bool]
-) {
-  let op = TFE_Op("AttrBoolList")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrDefault(
-  _ a: String = "banana"
-) {
-  let op = TFE_Op("AttrDefault")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrEmptyListDefault(
-  _ a: [Double]
-) {
-  let op = TFE_Op("AttrEmptyListDefault")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrEnum(
-  _ a: A
-) {
-  let op = TFE_Op("AttrEnum")
-  op.setAttr("a", a.cName)
-  op.execute()
-}
-
-@inlinable
-public static func attrEnumList(
-  _ a: [String]
-) {
-  let op = TFE_Op("AttrEnumList")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrFloat(
-  _ a: Double
-) {
-  let op = TFE_Op("AttrFloat")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrListDefault(
-  _ a: [Int32] = [5, 15]
-) {
-  let op = TFE_Op("AttrListDefault")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrListMin(
-  _ a: [Int32]
-) {
-  let op = TFE_Op("AttrListMin")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrListTypeDefault<T: TensorFlowScalar>(
-  _ a: [Tensor<T>],
-  _ b: [Tensor<T>]
-) {
-  let op = TFE_Op("AttrListTypeDefault")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("N", a.count)
-  let _ = op.addInputList(a)
-  let _ = op.addInputList(b)
-  op.execute()
-}
-
-@inlinable
-public static func attrMin(
-  _ a: Int64
-) {
-  let op = TFE_Op("AttrMin")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrPartialShape(
-  _ a: TensorShape?
-) {
-  let op = TFE_Op("AttrPartialShape")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrPartialShapeList(
-  _ a: [TensorShape?]
-) {
-  let op = TFE_Op("AttrPartialShapeList")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrShape(
-  _ a: TensorShape?
-) {
-  let op = TFE_Op("AttrShape")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrShapeList(
-  _ a: [TensorShape?]
-) {
-  let op = TFE_Op("AttrShapeList")
-  op.setAttr("a", a)
-  op.execute()
-}
-
-@inlinable
-public static func attrTypeDefault<T: TensorFlowScalar>(
-  _ a: Tensor<T>
-) {
-  let op = TFE_Op("AttrTypeDefault")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  op.execute()
-}
-
-/// Produces a visualization of audio data over time.
-///
-/// Spectrograms are a standard way of representing audio information as a series of
-/// slices of frequency information, one slice for each window of time. By joining
-/// these together into a sequence, they form a distinctive fingerprint of the sound
-/// over time.
-///
-/// This op expects to receive audio data as an input, stored as floats in the range
-/// -1 to 1, together with a window width in samples, and a stride specifying how
-/// far to move the window between slices. From this it generates a three
-/// dimensional output. The lowest dimension has an amplitude value for each
-/// frequency during that time slice. The next dimension is time, with successive
-/// frequency slices. The final dimension is for the channels in the input, so a
-/// stereo audio input would have two here for example.
-///
-/// This means the layout when converted and saved as an image is rotated 90 degrees
-/// clockwise from a typical spectrogram. Time is descending down the Y axis, and
-/// the frequency decreases from left to right.
-///
-/// Each value in the result represents the square root of the sum of the real and
-/// imaginary parts of an FFT on the current window of samples. In this way, the
-/// lowest dimension represents the power of each frequency in the current window,
-/// and adjacent windows are concatenated in the next dimension.
-///
-/// To get a more intuitive and visual look at what this operation does, you can run
-/// tensorflow/examples/wav_to_spectrogram to read in an audio file and save out the
-/// resulting spectrogram as a PNG image.
-///
-/// - Parameter input: Float representation of audio data.
-///
-/// - Attrs:
-///   - window_size: How wide the input window is in samples. For the highest efficiency
-///     this should be a power of two, but other values are accepted.
-///   - stride: How widely apart the center of adjacent sample windows should be.
-///   - magnitude_squared: Whether to return the squared magnitude or just the
-///     magnitude. Using squared magnitude can avoid extra calculations.
-///
-/// - Output spectrogram: 3D representation of the audio frequencies as an image.
-@inlinable
-public static func audioSpectrogram(
-  _ input: Tensor<Float>,
-  windowSize: Int64,
-  stride: Int64,
-  magnitudeSquared: Bool = false
-) -> Tensor<Float> {
-  let op = TFE_Op("AudioSpectrogram")
-  op.setAttr("window_size", windowSize)
-  op.setAttr("stride", stride)
-  op.setAttr("magnitude_squared", magnitudeSquared)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Outputs a `Summary` protocol buffer with audio.
-///
-/// The summary has up to `max_outputs` summary values containing audio. The
-/// audio is built from `tensor` which must be 3-D with shape `[batch_size,
-/// frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are
-/// assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`.
-///
-/// The `tag` argument is a scalar `Tensor` of type `string`.  It is used to
-/// build the `tag` of the summary values:
-///
-/// *  If `max_outputs` is 1, the summary value tag is '*tag*/audio'.
-/// *  If `max_outputs` is greater than 1, the summary value tags are
-///    generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc.
-///
-/// - Parameters:
-///   - tag: Scalar. Used to build the `tag` attribute of the summary values.
-///   - tensor: 2-D of shape `[batch_size, frames]`.
-///
-/// - Attrs:
-///   - sample_rate: The sample rate of the signal in hertz.
-///   - max_outputs: Max number of batch elements to generate audio for.
-///
-/// - Output summary: Scalar. Serialized `Summary` protocol buffer.
-@inlinable
-public static func audioSummary(
-  tag: StringTensor,
-  _ tensor: Tensor<Float>,
-  sampleRate: Double,
-  maxOutputs: Int64 = 3
-) -> StringTensor {
-  let op = TFE_Op("AudioSummary")
-  op.setAttr("sample_rate", sampleRate)
-  op.setAttr("max_outputs", maxOutputs)
-  let _ = op.addInput(tag)
-  let _ = op.addInput(tensor)
-  return op.execute(Int(1))
-}
-
-/// Outputs a `Summary` protocol buffer with audio.
-///
-/// The summary has up to `max_outputs` summary values containing audio. The
-/// audio is built from `tensor` which must be 3-D with shape `[batch_size,
-/// frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are
-/// assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`.
-///
-/// The `tag` argument is a scalar `Tensor` of type `string`.  It is used to
-/// build the `tag` of the summary values:
-///
-/// *  If `max_outputs` is 1, the summary value tag is '*tag*/audio'.
-/// *  If `max_outputs` is greater than 1, the summary value tags are
-///    generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc.
-///
-/// - Parameters:
-///   - tag: Scalar. Used to build the `tag` attribute of the summary values.
-///   - tensor: 2-D of shape `[batch_size, frames]`.
-///   - sample_rate: The sample rate of the signal in hertz.
-///
-/// - Attr max_outputs: Max number of batch elements to generate audio for.
-///
-/// - Output summary: Scalar. Serialized `Summary` protocol buffer.
-@inlinable
-public static func audioSummaryV2(
-  tag: StringTensor,
-  _ tensor: Tensor<Float>,
-  sampleRate: Tensor<Float>,
-  maxOutputs: Int64 = 3
-) -> StringTensor {
-  let op = TFE_Op("AudioSummaryV2")
-  op.setAttr("max_outputs", maxOutputs)
-  let _ = op.addInput(tag)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(sampleRate)
-  return op.execute(Int(1))
-}
-
-/// Performs average pooling on the input.
-///
-/// Each entry in `output` is the mean of the corresponding size `ksize`
-/// window in `value`.
-///
-/// - Parameter value: 4-D with shape `[batch, height, width, channels]`.
-///
-/// - Attrs:
-///   - ksize: The size of the sliding window for each dimension of `value`.
-///   - strides: The stride of the sliding window for each dimension of `value`.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, in_channels, in_height, in_width].
-///
-/// - Output output: The average pooled output tensor.
-@inlinable
-public static func avgPool<T: FloatingPoint & TensorFlowScalar>(
-  value: Tensor<T>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat = .nhwc
-) -> Tensor<T> {
-  let op = TFE_Op("AvgPool")
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(value)
-  return op.execute(Int(1))
-}
-
-/// Performs 3D average pooling on the input.
-///
-/// - Parameter input: Shape `[batch, depth, rows, cols, channels]` tensor to pool over.
-///
-/// - Attrs:
-///   - ksize: 1-D tensor of length 5. The size of the window for each dimension of
-///     the input tensor. Must have `ksize[0] = ksize[4] = 1`.
-///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
-///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: The data format of the input and output data. With the
-///     default format "NDHWC", the data is stored in the order of:
-///         [batch, in_depth, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCDHW", the data storage order is:
-///         [batch, in_channels, in_depth, in_height, in_width].
-///
-/// - Output output: The average pooled output tensor.
-@inlinable
-public static func avgPool3D<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat1 = .ndhwc
-) -> Tensor<T> {
-  let op = TFE_Op("AvgPool3D")
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Computes gradients of average pooling function.
-///
-/// - Parameters:
-///   - orig_input_shape: The original input dimensions.
-///   - grad: Output backprop of shape `[batch, depth, rows, cols, channels]`.
-///
-/// - Attrs:
-///   - ksize: 1-D tensor of length 5. The size of the window for each dimension of
-///     the input tensor. Must have `ksize[0] = ksize[4] = 1`.
-///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
-///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: The data format of the input and output data. With the
-///     default format "NDHWC", the data is stored in the order of:
-///         [batch, in_depth, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCDHW", the data storage order is:
-///         [batch, in_channels, in_depth, in_height, in_width].
-///
-/// - Output output: The backprop for input.
-@inlinable
-public static func avgPool3DGrad<T: FloatingPoint & TensorFlowScalar>(
-  origInputShape: Tensor<Int32>,
-  grad: Tensor<T>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat1 = .ndhwc
-) -> Tensor<T> {
-  let op = TFE_Op("AvgPool3DGrad")
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(origInputShape)
-  let _ = op.addInput(grad)
-  return op.execute(Int(1))
-}
-
-/// Computes gradients of the average pooling function.
-///
-/// - Parameters:
-///   - orig_input_shape: 1-D.  Shape of the original input to `avg_pool`.
-///   - grad: 4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t.
-///     the output of `avg_pool`.
-///
-/// - Attrs:
-///   - ksize: The size of the sliding window for each dimension of the input.
-///   - strides: The stride of the sliding window for each dimension of the input.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, in_channels, in_height, in_width].
-///
-/// - Output output: 4-D.  Gradients w.r.t. the input of `avg_pool`.
-@inlinable
-public static func avgPoolGrad<T: FloatingPoint & TensorFlowScalar>(
-  origInputShape: Tensor<Int32>,
-  grad: Tensor<T>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat = .nhwc
-) -> Tensor<T> {
-  let op = TFE_Op("AvgPoolGrad")
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(origInputShape)
-  let _ = op.addInput(grad)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func b(
-) -> Tensor<Float> {
-  let op = TFE_Op("B")
-  
-  return op.execute(Int(1))
-}
-
-/// Batches all input tensors nondeterministically.
-///
-/// When many instances of this Op are being run concurrently with the same
-/// container/shared_name in the same device, some will output zero-shaped Tensors
-/// and others will output Tensors of size up to max_batch_size.
-///
-/// All Tensors in in_tensors are batched together (so, for example, labels and
-/// features should be batched with a single instance of this operation.
-///
-/// Each invocation of batch emits an `id` scalar which will be used to identify
-/// this particular invocation when doing unbatch or its gradient.
-///
-/// Each op which emits a non-empty batch will also emit a non-empty batch_index
-/// Tensor, which, is a [K, 3] matrix where each row contains the invocation's id,
-/// start, and length of elements of each set of Tensors present in batched_tensors.
-///
-/// Batched tensors are concatenated along the first dimension, and all tensors in
-/// in_tensors must have the first dimension of the same size.
-///
-/// in_tensors: The tensors to be batched.
-/// num_batch_threads: Number of scheduling threads for processing batches of work.
-///  Determines the number of batches processed in parallel.
-/// max_batch_size: Batch sizes will never be bigger than this.
-/// batch_timeout_micros: Maximum number of microseconds to wait before outputting
-///  an incomplete batch.
-/// allowed_batch_sizes: Optional list of allowed batch sizes. If left empty, does
-///  nothing. Otherwise, supplies a list of batch sizes, causing the op to pad
-///  batches up to one of those sizes. The entries must increase monotonically, and
-///  the final entry must equal max_batch_size.
-/// grad_timeout_micros: The timeout to use for the gradient. See Unbatch.
-/// batched_tensors: Either empty tensors or a batch of concatenated Tensors.
-/// batch_index: If out_tensors is non-empty, has information to invert it.
-/// container: Controls the scope of sharing of this batch.
-/// id: always contains a scalar with a unique ID for this invocation of Batch.
-/// shared_name: Concurrently running instances of batch in the same device with the
-///  same container and shared_name will batch their elements together. If left
-///  empty, the op name will be used as the shared name.
-/// T: the types of tensors to be batched.
-@inlinable
-public static func batch<T: TensorArrayProtocol>(
-  inTensors: T,
-  numBatchThreads: Int64,
-  maxBatchSize: Int64,
-  maxEnqueuedBatches: Int64 = 10,
-  batchTimeoutMicros: Int64,
-  allowedBatchSizes: [Int32],
-  gradTimeoutMicros: Int64,
-  container: String,
-  sharedName: String,
-  batchingQueue: String
-) -> (batchedTensors: T, batchIndex: Tensor<Int64>, id: Tensor<Int64>) {
-  let op = TFE_Op("Batch")
-  op.setAttr("num_batch_threads", numBatchThreads)
-  op.setAttr("max_batch_size", maxBatchSize)
-  op.setAttr("max_enqueued_batches", maxEnqueuedBatches)
-  op.setAttr("batch_timeout_micros", batchTimeoutMicros)
-  op.setAttr("allowed_batch_sizes", allowedBatchSizes)
-  op.setAttr("grad_timeout_micros", gradTimeoutMicros)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("batching_queue", batchingQueue)
-  op.setAttr("T", inTensors._typeList)
-  let _ = op.addInputList(inTensors)
-  return op.execute(Int(inTensors._typeList.count), Int(1), Int(1))
-}
-
-@inlinable
-public static func batchCholesky<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BatchCholesky")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func batchCholeskyGrad<T: FloatingPoint & TensorFlowScalar>(
-  l: Tensor<T>,
-  grad: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BatchCholeskyGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(l)
-  let _ = op.addInput(grad)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that batches `batch_size` elements from `input_dataset`.
-///
-/// - Parameter batch_size: A scalar representing the number of elements to accumulate in a
-///   batch.
-@inlinable
-public static func batchDataset(
-  inputDataset: VariantHandle,
-  batchSize: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("BatchDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(batchSize)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that batches `batch_size` elements from `input_dataset`.
-///
-/// - Parameters:
-///   - batch_size: A scalar representing the number of elements to accumulate in a batch.
-///   - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
-///     is smaller than desired.
-@inlinable
-public static func batchDatasetV2(
-  inputDataset: VariantHandle,
-  batchSize: Tensor<Int64>,
-  dropRemainder: Tensor<Bool>,
-  parallelCopy: Bool = false,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("BatchDatasetV2")
-  op.setAttr("parallel_copy", parallelCopy)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(batchSize)
-  let _ = op.addInput(dropRemainder)
-  return op.execute(Int(1))
-}
-
-/// Batches all the inputs tensors to the computation done by the function.
-///
-/// So, for example, in the following code
-///
-///   ```python
-///
-///   # This input will be captured.
-///   y = tf.placeholder_with_default(1.0, shape=[])
-///
-///   @tf.Defun(tf.float32)
-///   def computation(a):
-///     return tf.matmul(a, a) + y
-///
-///   b = gen_batch_ops.batch_function(
-///           f=computation
-///           in_tensors=[a],
-///           captured_tensors=computation.captured_inputs,
-///           Tout=[o.type for o in computation.definition.signature.output_arg],
-///           num_batch_threads=1,
-///           max_batch_size=10,
-///           batch_timeout_micros=100000,  # 100ms
-///           allowed_batch_sizes=[3, 10],
-///           batching_queue="")
-///
-/// If more than one session.run call is simultaneously trying to compute `b`
-/// the values of `a` will be gathered, non-deterministically concatenated
-/// along the first axis, and only one thread will run the computation.
-///
-/// Assumes that all arguments of the function are Tensors which will be batched
-/// along their first dimension.
-///
-/// Arguments that are captured, are not batched. The session.run call which does
-/// the concatenation, will use the values of the captured tensors available to it.
-/// Therefore, typical uses of captured tensors should involve values which remain
-/// unchanged across session.run calls. Inference is a good example of this.
-///
-/// SparseTensor is not supported. The return value of the decorated function
-/// must be a Tensor or a list/tuple of Tensors.
-///
-/// - Parameters:
-///   - in_tensors: The tensors to be batched.
-///   - captured_tensors: The tensors which are captured in the function, and don't need
-///     to be batched.
-///
-/// - Attrs:
-///   - num_batch_threads: Number of scheduling threads for processing batches of work.
-///     Determines the number of batches processed in parallel.
-///   - max_batch_size: Batch sizes will never be bigger than this.
-///   - batch_timeout_micros: Maximum number of microseconds to wait before outputting
-///     an incomplete batch.
-///   - max_enqueued_batches: Maximum number of batches enqueued. Default: 10.
-///   - allowed_batch_sizes: Optional list of allowed batch sizes. If left empty, does
-///     nothing. Otherwise, supplies a list of batch sizes, causing the op to pad
-///     batches up to one of those sizes. The entries must increase monotonically, and
-///     the final entry must equal max_batch_size.
-///   - container: Controls the scope of sharing of this batch.
-///   - shared_name: Concurrently running instances of batch in the same device with the
-///     same container and shared_name will batch their elements together. If left
-///     empty, the op name will be used as the shared name.
-///   - Tin: the types of tensors to be batched.
-///   - Tcaptured: the types of the captured tensors.
-///   - Tout: the types of the output tensors.
-///
-/// - Output out_tensors: The output tensors.
-@inlinable
-public static func batchFunction<
-    FIn: TensorGroup,
-    FOut: TensorGroup,
-    Tin: TensorArrayProtocol,
-    Tcaptured: TensorArrayProtocol,
-    Tout: TensorGroup
->(
-  inTensors: Tin,
-  capturedTensors: Tcaptured,
-  f: (FIn) -> FOut,
-  numBatchThreads: Int64,
-  maxBatchSize: Int64,
-  batchTimeoutMicros: Int64,
-  maxEnqueuedBatches: Int64 = 10,
-  allowedBatchSizes: [Int32],
-  container: String,
-  sharedName: String,
-  batchingQueue: String
-) -> Tout {
-  let op = TFE_Op("BatchFunction")
-  op.setAttr("f", f)
-  op.setAttr("num_batch_threads", numBatchThreads)
-  op.setAttr("max_batch_size", maxBatchSize)
-  op.setAttr("batch_timeout_micros", batchTimeoutMicros)
-  op.setAttr("max_enqueued_batches", maxEnqueuedBatches)
-  op.setAttr("allowed_batch_sizes", allowedBatchSizes)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("batching_queue", batchingQueue)
-  op.setAttr("Tin", inTensors._typeList)
-  op.setAttr("Tcaptured", capturedTensors._typeList)
-  op.setAttr("Tout", Tout._typeList)
-  let _ = op.addInputList(inTensors)
-  let _ = op.addInputList(capturedTensors)
-  return op.execute(Int(Tout._typeList.count))
-}
-
-/// Multiplies slices of two tensors in batches.
-///
-/// Multiplies all slices of `Tensor` `x` and `y` (each slice can be
-/// viewed as an element of a batch), and arranges the individual results
-/// in a single output tensor of the same batch size. Each of the
-/// individual slices can optionally be adjointed (to adjoint a matrix
-/// means to transpose and conjugate it) before multiplication by setting
-/// the `adj_x` or `adj_y` flag to `True`, which are by default `False`.
-///
-/// The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]`
-/// and `[..., r_y, c_y]`.
-///
-/// The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where:
-///
-///     r_o = c_x if adj_x else r_x
-///     c_o = r_y if adj_y else c_y
-///
-/// It is computed as:
-///
-///     output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])
-///
-/// - Parameters:
-///   - x: 2-D or higher with shape `[..., r_x, c_x]`.
-///   - y: 2-D or higher with shape `[..., r_y, c_y]`.
-///
-/// - Attrs:
-///   - adj_x: If `True`, adjoint the slices of `x`. Defaults to `False`.
-///   - adj_y: If `True`, adjoint the slices of `y`. Defaults to `False`.
-///
-/// - Output output: 3-D or higher with shape `[..., r_o, c_o]`
-@inlinable
-public static func batchMatMul<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>,
-  adjX: Bool = false,
-  adjY: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("BatchMatMul")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("adj_x", adjX)
-  op.setAttr("adj_y", adjY)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Multiplies slices of two tensors in batches.
-///
-/// Multiplies all slices of `Tensor` `x` and `y` (each slice can be
-/// viewed as an element of a batch), and arranges the individual results
-/// in a single output tensor of the same batch size. Each of the
-/// individual slices can optionally be adjointed (to adjoint a matrix
-/// means to transpose and conjugate it) before multiplication by setting
-/// the `adj_x` or `adj_y` flag to `True`, which are by default `False`.
-///
-/// The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]`
-/// and `[..., r_y, c_y]`.
-///
-/// The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where:
-///
-///     r_o = c_x if adj_x else r_x
-///     c_o = r_y if adj_y else c_y
-///
-/// It is computed as:
-///
-///     output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])
-///
-/// *NOTE*: `BatchMatMulV2` supports broadcasting in the batch dimensions. More
-/// about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html).
-///
-///
-/// - Parameters:
-///   - x: 2-D or higher with shape `[..., r_x, c_x]`.
-///   - y: 2-D or higher with shape `[..., r_y, c_y]`.
-///
-/// - Attrs:
-///   - adj_x: If `True`, adjoint the slices of `x`. Defaults to `False`.
-///   - adj_y: If `True`, adjoint the slices of `y`. Defaults to `False`.
-///
-/// - Output output: 3-D or higher with shape `[..., r_o, c_o]`
-@inlinable
-public static func batchMatMulV2<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>,
-  adjX: Bool = false,
-  adjY: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("BatchMatMulV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("adj_x", adjX)
-  op.setAttr("adj_y", adjY)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func batchMatrixBandPart<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  numLower: Tensor<Int64>,
-  numUpper: Tensor<Int64>
-) -> Tensor<T> {
-  let op = TFE_Op("BatchMatrixBandPart")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(numLower)
-  let _ = op.addInput(numUpper)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func batchMatrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BatchMatrixDeterminant")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func batchMatrixDiag<T: TensorFlowScalar>(
-  diagonal: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BatchMatrixDiag")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(diagonal)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func batchMatrixDiagPart<T: TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BatchMatrixDiagPart")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func batchMatrixInverse<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  adjoint: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("BatchMatrixInverse")
-  op.setAttr("adjoint", adjoint)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func batchMatrixSetDiag<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  diagonal: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BatchMatrixSetDiag")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(diagonal)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func batchMatrixSolve<T: FloatingPoint & TensorFlowScalar>(
-  matrix: Tensor<T>,
-  rhs: Tensor<T>,
-  adjoint: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("BatchMatrixSolve")
-  op.setAttr("adjoint", adjoint)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(matrix)
-  let _ = op.addInput(rhs)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func batchMatrixSolveLs<T: FloatingPoint & TensorFlowScalar>(
-  matrix: Tensor<T>,
-  rhs: Tensor<T>,
-  l2Regularizer: Tensor<Double>,
-  fast: Bool = true
-) -> Tensor<T> {
-  let op = TFE_Op("BatchMatrixSolveLs")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("fast", fast)
-  let _ = op.addInput(matrix)
-  let _ = op.addInput(rhs)
-  let _ = op.addInput(l2Regularizer)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func batchMatrixTriangularSolve<T: FloatingPoint & TensorFlowScalar>(
-  matrix: Tensor<T>,
-  rhs: Tensor<T>,
-  lower: Bool = true,
-  adjoint: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("BatchMatrixTriangularSolve")
-  op.setAttr("lower", lower)
-  op.setAttr("adjoint", adjoint)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(matrix)
-  let _ = op.addInput(rhs)
-  return op.execute(Int(1))
-}
-
-/// Batch normalization.
-///
-/// This op is deprecated. Prefer `tf.nn.batch_normalization`.
-///
-/// - Parameters:
-///   - t: A 4D input Tensor.
-///   - m: A 1D mean Tensor with size matching the last dimension of t.
-///     This is the first output from tf.nn.moments,
-///     or a saved moving average thereof.
-///   - v: A 1D variance Tensor with size matching the last dimension of t.
-///     This is the second output from tf.nn.moments,
-///     or a saved moving average thereof.
-///   - beta: A 1D beta Tensor with size matching the last dimension of t.
-///     An offset to be added to the normalized tensor.
-///   - gamma: A 1D gamma Tensor with size matching the last dimension of t.
-///     If "scale_after_normalization" is true, this tensor will be multiplied
-///     with the normalized tensor.
-///
-/// - Attrs:
-///   - variance_epsilon: A small float number to avoid dividing by 0.
-///   - scale_after_normalization: A bool indicating whether the resulted tensor
-///     needs to be multiplied with gamma.
-@inlinable
-public static func batchNormWithGlobalNormalization<T: Numeric & TensorFlowScalar>(
-  t: Tensor<T>,
-  m: Tensor<T>,
-  v: Tensor<T>,
-  beta: Tensor<T>,
-  gamma: Tensor<T>,
-  varianceEpsilon: Double,
-  scaleAfterNormalization: Bool
-) -> Tensor<T> {
-  let op = TFE_Op("BatchNormWithGlobalNormalization")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("variance_epsilon", varianceEpsilon)
-  op.setAttr("scale_after_normalization", scaleAfterNormalization)
-  let _ = op.addInput(t)
-  let _ = op.addInput(m)
-  let _ = op.addInput(v)
-  let _ = op.addInput(beta)
-  let _ = op.addInput(gamma)
-  return op.execute(Int(1))
-}
-
-/// Gradients for batch normalization.
-///
-/// This op is deprecated. See `tf.nn.batch_normalization`.
-///
-/// - Parameters:
-///   - t: A 4D input Tensor.
-///   - m: A 1D mean Tensor with size matching the last dimension of t.
-///     This is the first output from tf.nn.moments,
-///     or a saved moving average thereof.
-///   - v: A 1D variance Tensor with size matching the last dimension of t.
-///     This is the second output from tf.nn.moments,
-///     or a saved moving average thereof.
-///   - gamma: A 1D gamma Tensor with size matching the last dimension of t.
-///     If "scale_after_normalization" is true, this Tensor will be multiplied
-///     with the normalized Tensor.
-///   - backprop: 4D backprop Tensor.
-///
-/// - Attrs:
-///   - variance_epsilon: A small float number to avoid dividing by 0.
-///   - scale_after_normalization: A bool indicating whether the resulted tensor
-///     needs to be multiplied with gamma.
-///
-/// - Outputs:
-///   - dx: 4D backprop tensor for input.
-///   - dm: 1D backprop tensor for mean.
-///   - dv: 1D backprop tensor for variance.
-///   - db: 1D backprop tensor for beta.
-///   - dg: 1D backprop tensor for gamma.
-@inlinable
-public static func batchNormWithGlobalNormalizationGrad<T: Numeric & TensorFlowScalar>(
-  t: Tensor<T>,
-  m: Tensor<T>,
-  v: Tensor<T>,
-  gamma: Tensor<T>,
-  backprop: Tensor<T>,
-  varianceEpsilon: Double,
-  scaleAfterNormalization: Bool
-) -> (dx: Tensor<T>, dm: Tensor<T>, dv: Tensor<T>, db: Tensor<T>, dg: Tensor<T>) {
-  let op = TFE_Op("BatchNormWithGlobalNormalizationGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("variance_epsilon", varianceEpsilon)
-  op.setAttr("scale_after_normalization", scaleAfterNormalization)
-  let _ = op.addInput(t)
-  let _ = op.addInput(m)
-  let _ = op.addInput(v)
-  let _ = op.addInput(gamma)
-  let _ = op.addInput(backprop)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func batchSelfAdjointEig<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BatchSelfAdjointEig")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func batchSelfAdjointEigV2<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  computeV: Bool = true
-) -> (e: Tensor<T>, v: Tensor<T>) {
-  let op = TFE_Op("BatchSelfAdjointEigV2")
-  op.setAttr("compute_v", computeV)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1), Int(1))
-}
-
-@inlinable
-public static func batchSvd<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  computeUv: Bool = true,
-  fullMatrices: Bool = false
-) -> (s: Tensor<T>, u: Tensor<T>, v: Tensor<T>) {
-  let op = TFE_Op("BatchSvd")
-  op.setAttr("compute_uv", computeUv)
-  op.setAttr("full_matrices", fullMatrices)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// BatchToSpace for 4-D tensors of type T.
-///
-/// This is a legacy version of the more general BatchToSpaceND.
-///
-/// Rearranges (permutes) data from batch into blocks of spatial data, followed by
-/// cropping. This is the reverse transformation of SpaceToBatch. More specifically,
-/// this op outputs a copy of the input tensor where values from the `batch`
-/// dimension are moved in spatial blocks to the `height` and `width` dimensions,
-/// followed by cropping along the `height` and `width` dimensions.
-///
-/// - Parameters:
-///   - input: 4-D tensor with shape
-///     `[batch*block_size*block_size, height_pad/block_size, width_pad/block_size,
-///       depth]`. Note that the batch size of the input tensor must be divisible by
-///     `block_size * block_size`.
-///   - crops: 2-D tensor of non-negative integers with shape `[2, 2]`. It specifies
-///     how many elements to crop from the intermediate result across the spatial
-///     dimensions as follows:
-///
-///         crops = [[crop_top, crop_bottom], [crop_left, crop_right]]
-///
-/// - Output output: 4-D with shape `[batch, height, width, depth]`, where:
-///
-///         height = height_pad - crop_top - crop_bottom
-///         width = width_pad - crop_left - crop_right
-///
-///   The attr `block_size` must be greater than one. It indicates the block size.
-///
-///   Some examples:
-///
-///   (1) For the following input of shape `[4, 1, 1, 1]` and block_size of 2:
-///
-///   ```
-///   [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
-///   ```
-///
-///   The output tensor has shape `[1, 2, 2, 1]` and value:
-///
-///   ```
-///   x = [[[[1], [2]], [[3], [4]]]]
-///   ```
-///
-///   (2) For the following input of shape `[4, 1, 1, 3]` and block_size of 2:
-///
-///   ```
-///   [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
-///   ```
-///
-///   The output tensor has shape `[1, 2, 2, 3]` and value:
-///
-///   ```
-///   x = [[[[1, 2, 3], [4, 5, 6]],
-///         [[7, 8, 9], [10, 11, 12]]]]
-///   ```
-///
-///   (3) For the following input of shape `[4, 2, 2, 1]` and block_size of 2:
-///
-///   ```
-///   x = [[[[1], [3]], [[9], [11]]],
-///        [[[2], [4]], [[10], [12]]],
-///        [[[5], [7]], [[13], [15]]],
-///        [[[6], [8]], [[14], [16]]]]
-///   ```
-///
-///   The output tensor has shape `[1, 4, 4, 1]` and value:
-///
-///   ```
-///   x = [[[[1],   [2],  [3],  [4]],
-///        [[5],   [6],  [7],  [8]],
-///        [[9],  [10], [11],  [12]],
-///        [[13], [14], [15],  [16]]]]
-///   ```
-///
-///   (4) For the following input of shape `[8, 1, 2, 1]` and block_size of 2:
-///
-///   ```
-///   x = [[[[1], [3]]], [[[9], [11]]], [[[2], [4]]], [[[10], [12]]],
-///        [[[5], [7]]], [[[13], [15]]], [[[6], [8]]], [[[14], [16]]]]
-///   ```
-///
-///   The output tensor has shape `[2, 2, 4, 1]` and value:
-///
-///   ```
-///   x = [[[[1], [3]], [[5], [7]]],
-///        [[[2], [4]], [[10], [12]]],
-///        [[[5], [7]], [[13], [15]]],
-///        [[[6], [8]], [[14], [16]]]]
-///   ```
-@inlinable
-public static func batchToSpace<
-    T: TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  crops: Tensor<Tidx>,
-  blockSize: Int64
-) -> Tensor<T> {
-  let op = TFE_Op("BatchToSpace")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("block_size", blockSize)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(crops)
-  return op.execute(Int(1))
-}
-
-/// BatchToSpace for N-D tensors of type T.
-///
-/// This operation reshapes the "batch" dimension 0 into `M + 1` dimensions of shape
-/// `block_shape + [batch]`, interleaves these blocks back into the grid defined by
-/// the spatial dimensions `[1, ..., M]`, to obtain a result with the same rank as
-/// the input.  The spatial dimensions of this intermediate result are then
-/// optionally cropped according to `crops` to produce the output.  This is the
-/// reverse of SpaceToBatch.  See below for a precise description.
-///
-/// - Parameters:
-///   - input: N-D with shape `input_shape = [batch] + spatial_shape + remaining_shape`,
-///     where spatial_shape has M dimensions.
-///   - block_shape: 1-D with shape `[M]`, all values must be >= 1.
-///   - crops: 2-D with shape `[M, 2]`, all values must be >= 0.
-///       `crops[i] = [crop_start, crop_end]` specifies the amount to crop from input
-///       dimension `i + 1`, which corresponds to spatial dimension `i`.  It is
-///       required that
-///       `crop_start[i] + crop_end[i] <= block_shape[i] * input_shape[i + 1]`.
-///
-///     This operation is equivalent to the following steps:
-///
-///     1. Reshape `input` to `reshaped` of shape:
-///          [block_shape[0], ..., block_shape[M-1],
-///           batch / prod(block_shape),
-///           input_shape[1], ..., input_shape[N-1]]
-///
-///     2. Permute dimensions of `reshaped` to produce `permuted` of shape
-///          [batch / prod(block_shape),
-///
-///           input_shape[1], block_shape[0],
-///           ...,
-///           input_shape[M], block_shape[M-1],
-///
-///           input_shape[M+1], ..., input_shape[N-1]]
-///
-///     3. Reshape `permuted` to produce `reshaped_permuted` of shape
-///          [batch / prod(block_shape),
-///
-///           input_shape[1] * block_shape[0],
-///           ...,
-///           input_shape[M] * block_shape[M-1],
-///
-///           input_shape[M+1],
-///           ...,
-///           input_shape[N-1]]
-///
-///     4. Crop the start and end of dimensions `[1, ..., M]` of
-///        `reshaped_permuted` according to `crops` to produce the output of shape:
-///          [batch / prod(block_shape),
-///
-///           input_shape[1] * block_shape[0] - crops[0,0] - crops[0,1],
-///           ...,
-///           input_shape[M] * block_shape[M-1] - crops[M-1,0] - crops[M-1,1],
-///
-///           input_shape[M+1], ..., input_shape[N-1]]
-///
-///     Some examples:
-///
-///     (1) For the following input of shape `[4, 1, 1, 1]`, `block_shape = [2, 2]`, and
-///         `crops = [[0, 0], [0, 0]]`:
-///
-///     ```
-///     [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
-///     ```
-///
-///     The output tensor has shape `[1, 2, 2, 1]` and value:
-///
-///     ```
-///     x = [[[[1], [2]], [[3], [4]]]]
-///     ```
-///
-///     (2) For the following input of shape `[4, 1, 1, 3]`, `block_shape = [2, 2]`, and
-///         `crops = [[0, 0], [0, 0]]`:
-///
-///     ```
-///     [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
-///     ```
-///
-///     The output tensor has shape `[1, 2, 2, 3]` and value:
-///
-///     ```
-///     x = [[[[1, 2, 3], [4, 5, 6]],
-///           [[7, 8, 9], [10, 11, 12]]]]
-///     ```
-///
-///     (3) For the following input of shape `[4, 2, 2, 1]`, `block_shape = [2, 2]`, and
-///         `crops = [[0, 0], [0, 0]]`:
-///
-///     ```
-///     x = [[[[1], [3]], [[9], [11]]],
-///          [[[2], [4]], [[10], [12]]],
-///          [[[5], [7]], [[13], [15]]],
-///          [[[6], [8]], [[14], [16]]]]
-///     ```
-///
-///     The output tensor has shape `[1, 4, 4, 1]` and value:
-///
-///     ```
-///     x = [[[[1],   [2],  [3],  [4]],
-///          [[5],   [6],  [7],  [8]],
-///          [[9],  [10], [11],  [12]],
-///          [[13], [14], [15],  [16]]]]
-///     ```
-///
-///     (4) For the following input of shape `[8, 1, 3, 1]`, `block_shape = [2, 2]`, and
-///         `crops = [[0, 0], [2, 0]]`:
-///
-///     ```
-///     x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
-///          [[[0], [2], [4]]], [[[0], [10], [12]]],
-///          [[[0], [5], [7]]], [[[0], [13], [15]]],
-///          [[[0], [6], [8]]], [[[0], [14], [16]]]]
-///     ```
-///
-///     The output tensor has shape `[2, 2, 4, 1]` and value:
-///
-///     ```
-///     x = [[[[1],   [2],  [3],  [4]],
-///           [[5],   [6],  [7],  [8]]],
-///          [[[9],  [10], [11],  [12]],
-///           [[13], [14], [15],  [16]]]]
-///     ```
-@inlinable
-public static func batchToSpaceND<
-    T: TensorFlowScalar,
-    TblockShape: BinaryInteger & TensorFlowScalar,
-    Tcrops: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  blockShape: Tensor<TblockShape>,
-  crops: Tensor<Tcrops>
-) -> Tensor<T> {
-  let op = TFE_Op("BatchToSpaceND")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tblock_shape", TblockShape.tensorFlowDataType)
-  op.setAttr("Tcrops", Tcrops.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(blockShape)
-  let _ = op.addInput(crops)
-  return op.execute(Int(1))
-}
-
-/// Computes the Bessel i0e function of `x` element-wise.
-///
-/// Exponentially scaled modified Bessel function of order 0 defined as
-/// `bessel_i0e(x) = exp(-abs(x)) bessel_i0(x)`.
-///
-/// This function is faster and numerically stabler than `bessel_i0(x)`.
-@inlinable
-public static func besselI0e<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BesselI0e")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the Bessel i1e function of `x` element-wise.
-///
-/// Exponentially scaled modified Bessel function of order 0 defined as
-/// `bessel_i1e(x) = exp(-abs(x)) bessel_i1(x)`.
-///
-/// This function is faster and numerically stabler than `bessel_i1(x)`.
-@inlinable
-public static func besselI1e<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BesselI1e")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Compute the regularized incomplete beta integral \\(I_x(a, b)\\).
-///
-/// The regularized incomplete beta integral is defined as:
-///
-///
-/// \\(I_x(a, b) = \frac{B(x; a, b)}{B(a, b)}\\)
-///
-/// where
-///
-///
-/// \\(B(x; a, b) = \int_0^x t^{a-1} (1 - t)^{b-1} dt\\)
-///
-///
-/// is the incomplete beta function and \\(B(a, b)\\) is the *complete*
-/// beta function.
-@inlinable
-public static func betainc<T: FloatingPoint & TensorFlowScalar>(
-  _ a: Tensor<T>,
-  _ b: Tensor<T>,
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Betainc")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Adds `bias` to `value`.
-///
-/// This is a special case of `tf.add` where `bias` is restricted to be 1-D.
-/// Broadcasting is supported, so `value` may have any number of dimensions.
-///
-/// - Parameters:
-///   - value: Any number of dimensions.
-///   - bias: 1-D with size the last dimension of `value`.
-///
-/// - Attr data_format: Specify the data format of the input and output data. With the
-///   default format "NHWC", the bias tensor will be added to the last dimension
-///   of the value tensor.
-///   Alternatively, the format could be "NCHW", the data storage order of:
-///       [batch, in_channels, in_height, in_width].
-///   The tensor will be added to "in_channels", the third-to-the-last
-///       dimension.
-///
-/// - Output output: Broadcasted sum of `value` and `bias`.
-@inlinable
-public static func biasAdd<T: Numeric & TensorFlowScalar>(
-  value: Tensor<T>,
-  bias: Tensor<T>,
-  dataFormat: DataFormat = .nhwc
-) -> Tensor<T> {
-  let op = TFE_Op("BiasAdd")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("data_format", dataFormat.cName)
-  let _ = op.addInput(value)
-  let _ = op.addInput(bias)
-  return op.execute(Int(1))
-}
-
-/// The backward operation for "BiasAdd" on the "bias" tensor.
-///
-/// It accumulates all the values from out_backprop into the feature dimension.
-/// For NHWC data format, the feature dimension is the last. For NCHW data format,
-/// the feature dimension is the third-to-last.
-///
-/// - Parameter out_backprop: Any number of dimensions.
-///
-/// - Attr data_format: Specify the data format of the input and output data. With the
-///   default format "NHWC", the bias tensor will be added to the last dimension
-///   of the value tensor.
-///   Alternatively, the format could be "NCHW", the data storage order of:
-///       [batch, in_channels, in_height, in_width].
-///   The tensor will be added to "in_channels", the third-to-the-last
-///       dimension.
-///
-/// - Output output: 1-D with size the feature dimension of `out_backprop`.
-@inlinable
-public static func biasAddGrad<T: Numeric & TensorFlowScalar>(
-  outBackprop: Tensor<T>,
-  dataFormat: DataFormat = .nhwc
-) -> Tensor<T> {
-  let op = TFE_Op("BiasAddGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("data_format", dataFormat.cName)
-  let _ = op.addInput(outBackprop)
-  return op.execute(Int(1))
-}
-
-/// Adds `bias` to `value`.
-///
-/// This is a deprecated version of BiasAdd and will be soon removed.
-///
-/// This is a special case of `tf.add` where `bias` is restricted to be 1-D.
-/// Broadcasting is supported, so `value` may have any number of dimensions.
-///
-/// - Parameters:
-///   - value: Any number of dimensions.
-///   - bias: 1-D with size the last dimension of `value`.
-///
-/// - Output output: Broadcasted sum of `value` and `bias`.
-@inlinable
-public static func biasAddV1<T: Numeric & TensorFlowScalar>(
-  value: Tensor<T>,
-  bias: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BiasAddV1")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(value)
-  let _ = op.addInput(bias)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func binary<T: TensorFlowScalar>(
-  _ a: Tensor<T>,
-  _ b: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Binary")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  return op.execute(Int(1))
-}
-
-/// Counts the number of occurrences of each value in an integer array.
-///
-/// Outputs a vector with length `size` and the same dtype as `weights`. If
-/// `weights` are empty, then index `i` stores the number of times the value `i` is
-/// counted in `arr`. If `weights` are non-empty, then index `i` stores the sum of
-/// the value in `weights` at each index where the corresponding value in `arr` is
-/// `i`.
-///
-/// Values in `arr` outside of the range [0, size) are ignored.
-///
-/// - Parameters:
-///   - arr: int32 `Tensor`.
-///   - size: non-negative int32 scalar `Tensor`.
-///   - weights: is an int32, int64, float32, or float64 `Tensor` with the same
-///     shape as `arr`, or a length-0 `Tensor`, in which case it acts as all weights
-///     equal to 1.
-///
-/// - Output bins: 1D `Tensor` with length equal to `size`. The counts or summed weights for
-///   each value in the range [0, size).
-@inlinable
-public static func bincount<T: Numeric & TensorFlowScalar>(
-  arr: Tensor<Int32>,
-  size: Tensor<Int32>,
-  weights: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Bincount")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(arr)
-  let _ = op.addInput(size)
-  let _ = op.addInput(weights)
-  return op.execute(Int(1))
-}
-
-/// Bitcasts a tensor from one type to another without copying data.
-///
-/// Given a tensor `input`, this operation returns a tensor that has the same buffer
-/// data as `input` with datatype `type`.
-///
-/// If the input datatype `T` is larger than the output datatype `type` then the
-/// shape changes from [...] to [..., sizeof(`T`)/sizeof(`type`)].
-///
-/// If `T` is smaller than `type`, the operator requires that the rightmost
-/// dimension be equal to sizeof(`type`)/sizeof(`T`). The shape then goes from
-/// [..., sizeof(`type`)/sizeof(`T`)] to [...].
-///
-/// tf.bitcast() and tf.cast() work differently when real dtype is casted as a complex dtype
-/// (e.g. tf.complex64 or tf.complex128) as tf.cast() make imaginary part 0 while tf.bitcast()
-/// gives module error.
-/// For example,
-///
-/// Example 1:
-/// ```python
-/// >>> a = [1., 2., 3.]
-/// >>> equality_bitcast = tf.bitcast(a,tf.complex128)
-/// tensorflow.python.framework.errors_impl.InvalidArgumentError: Cannot bitcast from float to complex128: shape [3] [Op:Bitcast]
-/// >>> equality_cast = tf.cast(a,tf.complex128)
-/// >>> print(equality_cast)
-/// tf.Tensor([1.+0.j 2.+0.j 3.+0.j], shape=(3,), dtype=complex128)
-/// ```
-/// Example 2:
-/// ```python
-/// >>> tf.bitcast(tf.constant(0xffffffff, dtype=tf.uint32), tf.uint8)
-/// <tf.Tensor: ... shape=(4,), dtype=uint8, numpy=array([255, 255, 255, 255], dtype=uint8)>
-/// ```
-/// Example 3:
-/// ```python
-/// >>> x = [1., 2., 3.]
-/// >>> y = [0., 2., 3.]
-/// >>> equality= tf.equal(x,y)
-/// >>> equality_cast = tf.cast(equality,tf.float32)
-/// >>> equality_bitcast = tf.bitcast(equality_cast,tf.uint8)
-/// >>> print(equality)
-/// tf.Tensor([False True True], shape=(3,), dtype=bool)
-/// >>> print(equality_cast)
-/// tf.Tensor([0. 1. 1.], shape=(3,), dtype=float32)
-/// >>> print(equality_bitcast)
-/// tf.Tensor(
-/// [[ 0 0 0 0]
-///  [ 0 0 128 63]
-///  [ 0 0 128 63]], shape=(3, 4), dtype=uint8)
-/// ```
-///
-/// *NOTE*: Bitcast is implemented as a low-level cast, so machines with different
-/// endian orderings will give different results.
-@inlinable
-public static func bitcast<
-    T: Numeric & TensorFlowScalar,
-    Type: Numeric & TensorFlowScalar
->(
-  _ input: Tensor<T>
-) -> Tensor<Type> {
-  let op = TFE_Op("Bitcast")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("type", Type.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Elementwise computes the bitwise AND of `x` and `y`.
-///
-/// The result will have those bits set, that are set in both `x` and `y`. The
-/// computation is performed on the underlying representations of `x` and `y`.
-@inlinable
-public static func bitwiseAnd<T: BinaryInteger & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BitwiseAnd")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Elementwise computes the bitwise OR of `x` and `y`.
-///
-/// The result will have those bits set, that are set in `x`, `y` or both. The
-/// computation is performed on the underlying representations of `x` and `y`.
-@inlinable
-public static func bitwiseOr<T: BinaryInteger & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BitwiseOr")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Elementwise computes the bitwise XOR of `x` and `y`.
-///
-/// The result will have those bits set, that are different in `x` and `y`. The
-/// computation is performed on the underlying representations of `x` and `y`.
-@inlinable
-public static func bitwiseXor<T: BinaryInteger & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BitwiseXor")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Computes the LSTM cell forward propagation for all the time steps.
-///
-/// This is equivalent to applying LSTMBlockCell in a loop, like so:
-///
-/// ```python
-/// for x1 in unpack(x):
-///   i1, cs1, f1, o1, ci1, co1, h1 = LSTMBlock(
-///     x1, cs_prev, h_prev, w, wci, wcf, wco, b)
-///   cs_prev = cs1
-///   h_prev = h1
-///   i.append(i1)
-///   cs.append(cs1)
-///   f.append(f1)
-///   o.append(o1)
-///   ci.append(ci1)
-///   co.append(co1)
-///   h.append(h1)
-/// return pack(i), pack(cs), pack(f), pack(o), pack(ci), pack(ch), pack(h)
-/// ```
-///
-/// - Parameters:
-///   - seq_len_max: Maximum time length actually used by this input. Outputs are padded
-///     with zeros beyond this length.
-///   - x: The sequence input to the LSTM, shape (timelen, batch_size, num_inputs).
-///   - cs_prev: Value of the initial cell state.
-///   - h_prev: Initial output of cell (to be used for peephole).
-///   - w: The weight matrix.
-///   - wci: The weight matrix for input gate peephole connection.
-///   - wcf: The weight matrix for forget gate peephole connection.
-///   - wco: The weight matrix for output gate peephole connection.
-///   - b: The bias vector.
-///
-/// - Attrs:
-///   - forget_bias: The forget gate bias.
-///   - cell_clip: Value to clip the 'cs' value to.
-///   - use_peephole: Whether to use peephole weights.
-///
-/// - Outputs:
-///   - i: The input gate over the whole time sequence.
-///   - cs: The cell state before the tanh over the whole time sequence.
-///   - f: The forget gate over the whole time sequence.
-///   - o: The output gate over the whole time sequence.
-///   - ci: The cell input over the whole time sequence.
-///   - co: The cell after the tanh over the whole time sequence.
-///   - h: The output h vector over the whole time sequence.
-@inlinable
-public static func blockLSTM<T: FloatingPoint & TensorFlowScalar>(
-  seqLenMax: Tensor<Int64>,
-  _ x: Tensor<T>,
-  csPrev: Tensor<T>,
-  hPrev: Tensor<T>,
-  w: Tensor<T>,
-  wci: Tensor<T>,
-  wcf: Tensor<T>,
-  wco: Tensor<T>,
-  _ b: Tensor<T>,
-  forgetBias: Double = 1,
-  cellClip: Double = 3,
-  usePeephole: Bool = false
-) -> (i: Tensor<T>, cs: Tensor<T>, f: Tensor<T>, o: Tensor<T>, ci: Tensor<T>, co: Tensor<T>, h: Tensor<T>) {
-  let op = TFE_Op("BlockLSTM")
-  op.setAttr("forget_bias", forgetBias)
-  op.setAttr("cell_clip", cellClip)
-  op.setAttr("use_peephole", usePeephole)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(seqLenMax)
-  let _ = op.addInput(x)
-  let _ = op.addInput(csPrev)
-  let _ = op.addInput(hPrev)
-  let _ = op.addInput(w)
-  let _ = op.addInput(wci)
-  let _ = op.addInput(wcf)
-  let _ = op.addInput(wco)
-  let _ = op.addInput(b)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Computes the LSTM cell backward propagation for the entire time sequence.
-///
-/// This implementation is to be used in conjunction of LSTMBlock.
-///
-/// - Parameters:
-///   - seq_len_max: Maximum time length actually used by this input. Outputs are padded
-///     with zeros beyond this length.
-///   - x: The sequence input to the LSTM, shape (timelen, batch_size, num_inputs).
-///   - cs_prev: Value of the initial cell state.
-///   - h_prev: Initial output of cell (to be used for peephole).
-///   - w: The weight matrix.
-///   - wci: The weight matrix for input gate peephole connection.
-///   - wcf: The weight matrix for forget gate peephole connection.
-///   - wco: The weight matrix for output gate peephole connection.
-///   - b: The bias vector.
-///   - i: The input gate over the whole time sequence.
-///   - cs: The cell state before the tanh over the whole time sequence.
-///   - f: The forget gate over the whole time sequence.
-///   - o: The output gate over the whole time sequence.
-///   - ci: The cell input over the whole time sequence.
-///   - co: The cell after the tanh over the whole time sequence.
-///   - h: The output h vector over the whole time sequence.
-///   - cs_grad: The current gradient of cs.
-///   - h_grad: The gradient of h vector.
-///
-/// - Attr use_peephole: Whether to use peephole weights.
-///
-/// - Outputs:
-///   - x_grad: The gradient of x to be back-propped.
-///   - cs_prev_grad: The gradient of cs_prev to be back-propped.
-///   - h_prev_grad: The gradient of h_prev to be back-propped.
-///   - w_grad: The gradient for w to be back-propped.
-///   - wci_grad: The gradient for wci to be back-propped.
-///   - wcf_grad: The gradient for wcf to be back-propped.
-///   - wco_grad: The gradient for wco to be back-propped.
-///   - b_grad: The gradient for w to be back-propped.
-@inlinable
-public static func blockLSTMGrad<T: FloatingPoint & TensorFlowScalar>(
-  seqLenMax: Tensor<Int64>,
-  _ x: Tensor<T>,
-  csPrev: Tensor<T>,
-  hPrev: Tensor<T>,
-  w: Tensor<T>,
-  wci: Tensor<T>,
-  wcf: Tensor<T>,
-  wco: Tensor<T>,
-  _ b: Tensor<T>,
-  i: Tensor<T>,
-  cs: Tensor<T>,
-  f: Tensor<T>,
-  o: Tensor<T>,
-  ci: Tensor<T>,
-  co: Tensor<T>,
-  h: Tensor<T>,
-  csGrad: Tensor<T>,
-  hGrad: Tensor<T>,
-  usePeephole: Bool
-) -> (xGrad: Tensor<T>, csPrevGrad: Tensor<T>, hPrevGrad: Tensor<T>, wGrad: Tensor<T>, wciGrad: Tensor<T>, wcfGrad: Tensor<T>, wcoGrad: Tensor<T>, bGrad: Tensor<T>) {
-  let op = TFE_Op("BlockLSTMGrad")
-  op.setAttr("use_peephole", usePeephole)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(seqLenMax)
-  let _ = op.addInput(x)
-  let _ = op.addInput(csPrev)
-  let _ = op.addInput(hPrev)
-  let _ = op.addInput(w)
-  let _ = op.addInput(wci)
-  let _ = op.addInput(wcf)
-  let _ = op.addInput(wco)
-  let _ = op.addInput(b)
-  let _ = op.addInput(i)
-  let _ = op.addInput(cs)
-  let _ = op.addInput(f)
-  let _ = op.addInput(o)
-  let _ = op.addInput(ci)
-  let _ = op.addInput(co)
-  let _ = op.addInput(h)
-  let _ = op.addInput(csGrad)
-  let _ = op.addInput(hGrad)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Aggregates the summary of accumulated stats for the batch.
-///
-/// The summary stats contains gradients and hessians accumulated for each node, feature dimension id and bucket.
-///
-/// - Parameters:
-///   - node_ids: int32; Rank 1 Tensor containing node ids for each example, shape [batch_size].
-///   - gradients: float32; Rank 2 Tensor (shape=[batch_size, logits_dimension]) with gradients for each example.
-///   - hessians: float32; Rank 2 Tensor (shape=[batch_size, hessian_dimension]) with hessians for each example.
-///   - feature: int32; Rank 2 feature Tensors (shape=[batch_size, feature_dimension]).
-///
-/// - Attrs:
-///   - max_splits: int; the maximum number of splits possible in the whole tree.
-///   - num_buckets: int; equals to the maximum possible value of bucketized feature.
-///
-/// - Output stats_summary: output Rank 4 Tensor (shape=[splits, feature_dimension, buckets, logits_dimension + hessian_dimension])
-///   containing accumulated stats for each node, feature dimension and bucket.
-@inlinable
-public static func boostedTreesAggregateStats(
-  nodeIds: Tensor<Int32>,
-  gradients: Tensor<Float>,
-  hessians: Tensor<Float>,
-  feature: Tensor<Int32>,
-  maxSplits: Int64,
-  numBuckets: Int64
-) -> Tensor<Float> {
-  let op = TFE_Op("BoostedTreesAggregateStats")
-  op.setAttr("max_splits", maxSplits)
-  op.setAttr("num_buckets", numBuckets)
-  let _ = op.addInput(nodeIds)
-  let _ = op.addInput(gradients)
-  let _ = op.addInput(hessians)
-  let _ = op.addInput(feature)
-  return op.execute(Int(1))
-}
-
-/// Bucketize each feature based on bucket boundaries.
-///
-/// An op that returns a list of float tensors, where each tensor represents the
-/// bucketized values for a single feature.
-///
-/// - Parameters:
-///   - float_values: float; List of Rank 1 Tensor each containing float values for a single feature.
-///   - bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a single
-///     feature.
-///
-/// - Attr num_features: inferred int; number of features.
-///
-/// - Output buckets: int; List of Rank 1 Tensors each containing the bucketized values for a single feature.
-@inlinable
-public static func boostedTreesBucketize(
-  floatValues: [Tensor<Float>],
-  bucketBoundaries: [Tensor<Float>]
-) -> [Tensor<Int32>] {
-  let op = TFE_Op("BoostedTreesBucketize")
-  op.setAttr("num_features", floatValues.count)
-  let _ = op.addInputList(floatValues)
-  let _ = op.addInputList(bucketBoundaries)
-  return op.execute(Int(floatValues.count))
-}
-
-/// Calculates gains for each feature and returns the best possible split information for the feature.
-///
-/// The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature.
-///
-/// It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split.
-///
-/// In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features).
-///
-/// The output shapes are compatible in a way that the first dimension of all tensors are the same and equal to the number of possible split nodes for each feature.
-///
-/// - Parameters:
-///   - node_id_range: A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive).
-///   - stats_summary: A Rank 4 tensor (#shape=[max_splits, feature_dims, bucket, stats_dims]) for accumulated stats summary (gradient/hessian) per node, per dimension, per buckets for each feature.
-///     The first dimension of the tensor is the maximum number of splits, and thus not all elements of it will be used, but only the indexes specified by node_ids will be used.
-///   - l1: l1 regularization factor on leaf weights, per instance based.
-///   - l2: l2 regularization factor on leaf weights, per instance based.
-///   - tree_complexity: adjustment to the gain, per leaf based.
-///   - min_node_weight: mininum avg of hessians in a node before required for the node to be considered for splitting.
-///
-/// - Attrs:
-///   - logits_dimension: The dimension of logit, i.e., number of classes.
-///   - split_type: A string indicating if this Op should perform inequality split or equality split.
-///
-/// - Outputs:
-///   - node_ids: A Rank 1 tensors indicating possible split node ids for each feature. The length of the list is num_features, but each tensor has different size as each feature provides different possible nodes. See above for details like shapes and sizes.
-///   - gains: A Rank 1 tensors indicating the best gains for each feature to split for certain nodes. See above for details like shapes and sizes.
-///   - feature_dimensions: A Rank 1 tensors indicating the best feature dimension for each feature to split for certain nodes if the feature is multi-dimension. See above for details like shapes and sizes.
-///   - thresholds: A Rank 1 tensors indicating the bucket id to compare with (as a threshold) for split in each node. See above for details like shapes and sizes.
-///   - left_node_contribs: A Rank 2 tensors indicating the contribution of the left nodes when branching from parent nodes (given by the tensor element in the output node_ids_list) to the left direction by the given threshold for each feature. This value will be used to make the left node value by adding to the parent node value. Second dimension size is 1 for 1-dimensional logits, but would be larger for multi-class problems. See above for details like shapes and sizes.
-///   - right_node_contribs: A Rank 2 tensors, with the same shape/conditions as left_node_contribs_list, but just that the value is for the right node.
-///   - split_with_default_directions: A Rank 1 tensors indicating the which direction to go if data is missing. See above for details like shapes and sizes.
-@inlinable
-public static func boostedTreesCalculateBestFeatureSplit(
-  nodeIdRange: Tensor<Int32>,
-  statsSummary: Tensor<Float>,
-  l1: Tensor<Float>,
-  l2: Tensor<Float>,
-  treeComplexity: Tensor<Float>,
-  minNodeWeight: Tensor<Float>,
-  logitsDimension: Int64,
-  splitType: SplitType = .inequality
-) -> (nodeIds: Tensor<Int32>, gains: Tensor<Float>, featureDimensions: Tensor<Int32>, thresholds: Tensor<Int32>, leftNodeContribs: Tensor<Float>, rightNodeContribs: Tensor<Float>, splitWithDefaultDirections: StringTensor) {
-  let op = TFE_Op("BoostedTreesCalculateBestFeatureSplit")
-  op.setAttr("logits_dimension", logitsDimension)
-  op.setAttr("split_type", splitType.cName)
-  let _ = op.addInput(nodeIdRange)
-  let _ = op.addInput(statsSummary)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  let _ = op.addInput(treeComplexity)
-  let _ = op.addInput(minNodeWeight)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Calculates gains for each feature and returns the best possible split information for the feature.
-///
-/// The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature.
-///
-/// It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split.
-///
-/// In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features).
-///
-/// The length of output lists are all of the same length, `num_features`.
-/// The output shapes are compatible in a way that the first dimension of all tensors of all lists are the same and equal to the number of possible split nodes for each feature.
-///
-/// - Parameters:
-///   - node_id_range: A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive).
-///   - stats_summary_list: A list of Rank 3 tensor (#shape=[max_splits, bucket, 2]) for accumulated stats summary (gradient/hessian) per node per buckets for each feature. The first dimension of the tensor is the maximum number of splits, and thus not all elements of it will be used, but only the indexes specified by node_ids will be used.
-///   - l1: l1 regularization factor on leaf weights, per instance based.
-///   - l2: l2 regularization factor on leaf weights, per instance based.
-///   - tree_complexity: adjustment to the gain, per leaf based.
-///   - min_node_weight: mininum avg of hessians in a node before required for the node to be considered for splitting.
-///
-/// - Attrs:
-///   - max_splits: the number of nodes that can be split in the whole tree. Used as a dimension of output tensors.
-///   - num_features: inferred from the size of `stats_summary_list`; the number of total features.
-///
-/// - Outputs:
-///   - node_ids_list: An output list of Rank 1 tensors indicating possible split node ids for each feature. The length of the list is num_features, but each tensor has different size as each feature provides different possible nodes. See above for details like shapes and sizes.
-///   - gains_list: An output list of Rank 1 tensors indicating the best gains for each feature to split for certain nodes. See above for details like shapes and sizes.
-///   - thresholds_list: An output list of Rank 1 tensors indicating the bucket id to compare with (as a threshold) for split in each node. See above for details like shapes and sizes.
-///   - left_node_contribs_list: A list of Rank 2 tensors indicating the contribution of the left nodes when branching from parent nodes (given by the tensor element in the output node_ids_list) to the left direction by the given threshold for each feature. This value will be used to make the left node value by adding to the parent node value. Second dimension size is 1 for 1-dimensional logits, but would be larger for multi-class problems. See above for details like shapes and sizes.
-///   - right_node_contribs_list: A list of Rank 2 tensors, with the same shape/conditions as left_node_contribs_list, but just that the value is for the right node.
-@inlinable
-public static func boostedTreesCalculateBestGainsPerFeature(
-  nodeIdRange: Tensor<Int32>,
-  statsSummaryList: [Tensor<Float>],
-  l1: Tensor<Float>,
-  l2: Tensor<Float>,
-  treeComplexity: Tensor<Float>,
-  minNodeWeight: Tensor<Float>,
-  maxSplits: Int64
-) -> (nodeIdsList: [Tensor<Int32>], gainsList: [Tensor<Float>], thresholdsList: [Tensor<Int32>], leftNodeContribsList: [Tensor<Float>], rightNodeContribsList: [Tensor<Float>]) {
-  let op = TFE_Op("BoostedTreesCalculateBestGainsPerFeature")
-  op.setAttr("max_splits", maxSplits)
-  op.setAttr("num_features", statsSummaryList.count)
-  let _ = op.addInput(nodeIdRange)
-  let _ = op.addInputList(statsSummaryList)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  let _ = op.addInput(treeComplexity)
-  let _ = op.addInput(minNodeWeight)
-  return op.execute(Int(statsSummaryList.count), Int(statsSummaryList.count), Int(statsSummaryList.count), Int(statsSummaryList.count), Int(statsSummaryList.count))
-}
-
-/// Calculates the prior from the training data (the bias) and fills in the first node with the logits' prior. Returns a boolean indicating whether to continue centering.
-///
-/// - Parameters:
-///   - tree_ensemble_handle: Handle to the tree ensemble.
-///   - mean_gradients: A tensor with shape=[logits_dimension] with mean of gradients for a first node.
-///   - mean_hessians: A tensor with shape=[logits_dimension] mean of hessians for a first node.
-///   - l1: l1 regularization factor on leaf weights, per instance based.
-///   - l2: l2 regularization factor on leaf weights, per instance based.
-///
-/// - Output continue_centering: Bool, whether to continue bias centering.
-@inlinable
-public static func boostedTreesCenterBias(
-  treeEnsembleHandle: ResourceHandle,
-  meanGradients: Tensor<Float>,
-  meanHessians: Tensor<Float>,
-  l1: Tensor<Float>,
-  l2: Tensor<Float>
-) -> Tensor<Bool> {
-  let op = TFE_Op("BoostedTreesCenterBias")
-  let _ = op.addInput(treeEnsembleHandle)
-  let _ = op.addInput(meanGradients)
-  let _ = op.addInput(meanHessians)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  return op.execute(Int(1))
-}
-
-/// Creates a tree ensemble model and returns a handle to it.
-///
-/// - Parameters:
-///   - tree_ensemble_handle: Handle to the tree ensemble resource to be created.
-///   - stamp_token: Token to use as the initial value of the resource stamp.
-///   - tree_ensemble_serialized: Serialized proto of the tree ensemble.
-@inlinable
-public static func boostedTreesCreateEnsemble(
-  treeEnsembleHandle: ResourceHandle,
-  stampToken: Tensor<Int64>,
-  treeEnsembleSerialized: StringTensor
-) {
-  let op = TFE_Op("BoostedTreesCreateEnsemble")
-  let _ = op.addInput(treeEnsembleHandle)
-  let _ = op.addInput(stampToken)
-  let _ = op.addInput(treeEnsembleSerialized)
-  op.execute()
-}
-
-/// Create the Resource for Quantile Streams.
-///
-/// - Parameters:
-///   - quantile_stream_resource_handle: resource; Handle to quantile stream resource.
-///   - epsilon: float; The required approximation error of the stream resource.
-///   - num_streams: int; The number of streams managed by the resource that shares the same epsilon.
-///
-/// - Attr max_elements: int; The maximum number of data points that can be fed to the stream.
-@inlinable
-public static func boostedTreesCreateQuantileStreamResource(
-  quantileStreamResourceHandle: ResourceHandle,
-  epsilon: Tensor<Float>,
-  numStreams: Tensor<Int64>,
-  maxElements: Int64 = 1099511627776
-) {
-  let op = TFE_Op("BoostedTreesCreateQuantileStreamResource")
-  op.setAttr("max_elements", maxElements)
-  let _ = op.addInput(quantileStreamResourceHandle)
-  let _ = op.addInput(epsilon)
-  let _ = op.addInput(numStreams)
-  op.execute()
-}
-
-/// Deserializes a serialized tree ensemble config and replaces current tree
-///
-/// ensemble.
-///
-/// - Parameters:
-///   - tree_ensemble_handle: Handle to the tree ensemble.
-///   - stamp_token: Token to use as the new value of the resource stamp.
-///   - tree_ensemble_serialized: Serialized proto of the ensemble.
-@inlinable
-public static func boostedTreesDeserializeEnsemble(
-  treeEnsembleHandle: ResourceHandle,
-  stampToken: Tensor<Int64>,
-  treeEnsembleSerialized: StringTensor
-) {
-  let op = TFE_Op("BoostedTreesDeserializeEnsemble")
-  let _ = op.addInput(treeEnsembleHandle)
-  let _ = op.addInput(stampToken)
-  let _ = op.addInput(treeEnsembleSerialized)
-  op.execute()
-}
-
-/// Creates a handle to a BoostedTreesEnsembleResource
-@inlinable
-public static func boostedTreesEnsembleResourceHandleOp(
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("BoostedTreesEnsembleResourceHandleOp")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Debugging/model interpretability outputs for each example.
-///
-/// It traverses all the trees and computes debug metrics for individual examples, 
-/// such as getting split feature ids and logits after each split along the decision
-/// path used to compute directional feature contributions.
-///
-/// - Parameter bucketized_features: A list of rank 1 Tensors containing bucket id for each
-///   feature.
-///
-/// - Attrs:
-///   - num_bucketized_features: Inferred.
-///   - logits_dimension: scalar, dimension of the logits, to be used for constructing the protos in
-///     examples_debug_outputs_serialized.
-///
-/// - Output examples_debug_outputs_serialized: Output rank 1 Tensor containing a proto serialized as a string for each example.
-@inlinable
-public static func boostedTreesExampleDebugOutputs(
-  treeEnsembleHandle: ResourceHandle,
-  bucketizedFeatures: [Tensor<Int32>],
-  logitsDimension: Int64
-) -> StringTensor {
-  let op = TFE_Op("BoostedTreesExampleDebugOutputs")
-  op.setAttr("num_bucketized_features", bucketizedFeatures.count)
-  op.setAttr("logits_dimension", logitsDimension)
-  let _ = op.addInput(treeEnsembleHandle)
-  let _ = op.addInputList(bucketizedFeatures)
-  return op.execute(Int(1))
-}
-
-/// Retrieves the tree ensemble resource stamp token, number of trees and growing statistics.
-///
-/// - Parameter tree_ensemble_handle: Handle to the tree ensemble.
-///
-/// - Outputs:
-///   - stamp_token: Stamp token of the tree ensemble resource.
-///   - num_trees: The number of trees in the tree ensemble resource.
-///   - num_finalized_trees: The number of trees that were finished successfully.
-///   - num_attempted_layers: The number of layers we attempted to build (but not necessarily succeeded).
-///   - last_layer_nodes_range: Rank size 2 tensor that contains start and end ids of the nodes in the latest
-///     layer.
-@inlinable
-public static func boostedTreesGetEnsembleStates(
-  treeEnsembleHandle: ResourceHandle
-) -> (stampToken: Tensor<Int64>, numTrees: Tensor<Int32>, numFinalizedTrees: Tensor<Int32>, numAttemptedLayers: Tensor<Int32>, lastLayerNodesRange: Tensor<Int32>) {
-  let op = TFE_Op("BoostedTreesGetEnsembleStates")
-  let _ = op.addInput(treeEnsembleHandle)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Makes the summary of quantiles for the batch.
-///
-/// An op that takes a list of tensors (one tensor per feature) and outputs the
-/// quantile summaries for each tensor.
-///
-/// - Parameters:
-///   - float_values: float; List of Rank 1 Tensors each containing values for a single feature.
-///   - example_weights: float; Rank 1 Tensor with weights per instance.
-///   - epsilon: float; The required maximum approximation error.
-///
-/// - Attr num_features: int; Inferred from the size of float_values.
-///   The number of float features.
-///
-/// - Output summaries: float; List of Rank 2 Tensors each containing the quantile summary
-///   (value, weight, min_rank, max_rank) of a single feature.
-@inlinable
-public static func boostedTreesMakeQuantileSummaries(
-  floatValues: [Tensor<Float>],
-  exampleWeights: Tensor<Float>,
-  epsilon: Tensor<Float>
-) -> [Tensor<Float>] {
-  let op = TFE_Op("BoostedTreesMakeQuantileSummaries")
-  op.setAttr("num_features", floatValues.count)
-  let _ = op.addInputList(floatValues)
-  let _ = op.addInput(exampleWeights)
-  let _ = op.addInput(epsilon)
-  return op.execute(Int(floatValues.count))
-}
-
-/// Makes the summary of accumulated stats for the batch.
-///
-/// The summary stats contains gradients and hessians accumulated into the corresponding node and bucket for each example.
-///
-/// - Parameters:
-///   - node_ids: int32 Rank 1 Tensor containing node ids, which each example falls into for the requested layer.
-///   - gradients: float32; Rank 2 Tensor (shape=[#examples, 1]) for gradients.
-///   - hessians: float32; Rank 2 Tensor (shape=[#examples, 1]) for hessians.
-///   - bucketized_features_list: int32 list of Rank 1 Tensors, each containing the bucketized feature (for each feature column).
-///
-/// - Attrs:
-///   - max_splits: int; the maximum number of splits possible in the whole tree.
-///   - num_buckets: int; equals to the maximum possible value of bucketized feature.
-///   - num_features: int; inferred from the size of bucketized_features_list; the number of features.
-///
-/// - Output stats_summary: output Rank 4 Tensor (shape=[#features, #splits, #buckets, 2]) containing accumulated stats put into the corresponding node and bucket. The first index of 4th dimension refers to gradients, and the second to hessians.
-@inlinable
-public static func boostedTreesMakeStatsSummary(
-  nodeIds: Tensor<Int32>,
-  gradients: Tensor<Float>,
-  hessians: Tensor<Float>,
-  bucketizedFeaturesList: [Tensor<Int32>],
-  maxSplits: Int64,
-  numBuckets: Int64
-) -> Tensor<Float> {
-  let op = TFE_Op("BoostedTreesMakeStatsSummary")
-  op.setAttr("max_splits", maxSplits)
-  op.setAttr("num_buckets", numBuckets)
-  op.setAttr("num_features", bucketizedFeaturesList.count)
-  let _ = op.addInput(nodeIds)
-  let _ = op.addInput(gradients)
-  let _ = op.addInput(hessians)
-  let _ = op.addInputList(bucketizedFeaturesList)
-  return op.execute(Int(1))
-}
-
-/// Runs multiple additive regression ensemble predictors on input instances and
-///
-/// computes the logits. It is designed to be used during prediction.
-/// It traverses all the trees and calculates the final score for each instance.
-///
-/// - Parameter bucketized_features: A list of rank 1 Tensors containing bucket id for each
-///   feature.
-///
-/// - Attrs:
-///   - num_bucketized_features: Inferred.
-///   - logits_dimension: scalar, dimension of the logits, to be used for partial logits
-///     shape.
-///
-/// - Output logits: Output rank 2 Tensor containing logits for each example.
-@inlinable
-public static func boostedTreesPredict(
-  treeEnsembleHandle: ResourceHandle,
-  bucketizedFeatures: [Tensor<Int32>],
-  logitsDimension: Int64
-) -> Tensor<Float> {
-  let op = TFE_Op("BoostedTreesPredict")
-  op.setAttr("num_bucketized_features", bucketizedFeatures.count)
-  op.setAttr("logits_dimension", logitsDimension)
-  let _ = op.addInput(treeEnsembleHandle)
-  let _ = op.addInputList(bucketizedFeatures)
-  return op.execute(Int(1))
-}
-
-/// Add the quantile summaries to each quantile stream resource.
-///
-/// An op that adds a list of quantile summaries to a quantile stream resource. Each
-/// summary Tensor is rank 2, containing summaries (value, weight, min_rank, max_rank)
-/// for a single feature.
-///
-/// - Parameters:
-///   - quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
-///   - summaries: string; List of Rank 2 Tensor each containing the summaries for a single feature.
-@inlinable
-public static func boostedTreesQuantileStreamResourceAddSummaries(
-  quantileStreamResourceHandle: ResourceHandle,
-  summaries: [Tensor<Float>]
-) {
-  let op = TFE_Op("BoostedTreesQuantileStreamResourceAddSummaries")
-  op.setAttr("num_features", summaries.count)
-  let _ = op.addInput(quantileStreamResourceHandle)
-  let _ = op.addInputList(summaries)
-  op.execute()
-}
-
-/// Deserialize bucket boundaries and ready flag into current QuantileAccumulator.
-///
-/// An op that deserializes bucket boundaries and are boundaries ready flag into current QuantileAccumulator.
-///
-/// - Parameters:
-///   - quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
-///   - bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a feature.
-///
-/// - Attr num_streams: inferred int; number of features to get bucket boundaries for.
-@inlinable
-public static func boostedTreesQuantileStreamResourceDeserialize(
-  quantileStreamResourceHandle: ResourceHandle,
-  bucketBoundaries: [Tensor<Float>]
-) {
-  let op = TFE_Op("BoostedTreesQuantileStreamResourceDeserialize")
-  op.setAttr("num_streams", bucketBoundaries.count)
-  let _ = op.addInput(quantileStreamResourceHandle)
-  let _ = op.addInputList(bucketBoundaries)
-  op.execute()
-}
-
-/// Flush the summaries for a quantile stream resource.
-///
-/// An op that flushes the summaries for a quantile stream resource.
-///
-/// - Parameters:
-///   - quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
-///   - num_buckets: int; approximate number of buckets unless using generate_quantiles.
-///
-/// - Attr generate_quantiles: bool; If True, the output will be the num_quantiles for each stream where the ith
-///   entry is the ith quantile of the input with an approximation error of epsilon.
-///   Duplicate values may be present.
-///   If False, the output will be the points in the histogram that we got which roughly
-///   translates to 1/epsilon boundaries and without any duplicates.
-///   Default to False.
-@inlinable
-public static func boostedTreesQuantileStreamResourceFlush(
-  quantileStreamResourceHandle: ResourceHandle,
-  numBuckets: Tensor<Int64>,
-  generateQuantiles: Bool = false
-) {
-  let op = TFE_Op("BoostedTreesQuantileStreamResourceFlush")
-  op.setAttr("generate_quantiles", generateQuantiles)
-  let _ = op.addInput(quantileStreamResourceHandle)
-  let _ = op.addInput(numBuckets)
-  op.execute()
-}
-
-/// Generate the bucket boundaries for each feature based on accumulated summaries.
-///
-/// An op that returns a list of float tensors for a quantile stream resource. Each
-/// tensor is Rank 1 containing bucket boundaries for a single feature.
-///
-/// - Parameter quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
-///
-/// - Attr num_features: inferred int; number of features to get bucket boundaries for.
-///
-/// - Output bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a feature.
-@inlinable
-public static func boostedTreesQuantileStreamResourceGetBucketBoundaries(
-  quantileStreamResourceHandle: ResourceHandle,
-  numFeatures: Int64
-) -> [Tensor<Float>] {
-  let op = TFE_Op("BoostedTreesQuantileStreamResourceGetBucketBoundaries")
-  op.setAttr("num_features", numFeatures)
-  let _ = op.addInput(quantileStreamResourceHandle)
-  return op.execute(Int(numFeatures))
-}
-
-/// Creates a handle to a BoostedTreesQuantileStreamResource.
-@inlinable
-public static func boostedTreesQuantileStreamResourceHandleOp(
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("BoostedTreesQuantileStreamResourceHandleOp")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Serializes the tree ensemble to a proto.
-///
-/// - Parameter tree_ensemble_handle: Handle to the tree ensemble.
-///
-/// - Outputs:
-///   - stamp_token: Stamp token of the tree ensemble resource.
-///   - tree_ensemble_serialized: Serialized proto of the ensemble.
-@inlinable
-public static func boostedTreesSerializeEnsemble(
-  treeEnsembleHandle: ResourceHandle
-) -> (stampToken: Tensor<Int64>, treeEnsembleSerialized: StringTensor) {
-  let op = TFE_Op("BoostedTreesSerializeEnsemble")
-  let _ = op.addInput(treeEnsembleHandle)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Runs multiple additive regression ensemble predictors on input instances and
-///
-/// computes the update to cached logits. It is designed to be used during training.
-/// It traverses the trees starting from cached tree id and cached node id and
-/// calculates the updates to be pushed to the cache.
-///
-/// - Parameters:
-///   - cached_tree_ids: Rank 1 Tensor containing cached tree ids which is the starting
-///     tree of prediction.
-///   - cached_node_ids: Rank 1 Tensor containing cached node id which is the starting
-///     node of prediction.
-///   - bucketized_features: A list of rank 1 Tensors containing bucket id for each
-///     feature.
-///
-/// - Attrs:
-///   - num_bucketized_features: Inferred.
-///   - logits_dimension: scalar, dimension of the logits, to be used for partial logits
-///     shape.
-///
-/// - Outputs:
-///   - partial_logits: Rank 2 Tensor containing logits update (with respect to cached
-///     values stored) for each example.
-///   - tree_ids: Rank 1 Tensor containing new tree ids for each example.
-///   - node_ids: Rank 1 Tensor containing new node ids in the new tree_ids.
-@inlinable
-public static func boostedTreesTrainingPredict(
-  treeEnsembleHandle: ResourceHandle,
-  cachedTreeIds: Tensor<Int32>,
-  cachedNodeIds: Tensor<Int32>,
-  bucketizedFeatures: [Tensor<Int32>],
-  logitsDimension: Int64
-) -> (partialLogits: Tensor<Float>, treeIds: Tensor<Int32>, nodeIds: Tensor<Int32>) {
-  let op = TFE_Op("BoostedTreesTrainingPredict")
-  op.setAttr("num_bucketized_features", bucketizedFeatures.count)
-  op.setAttr("logits_dimension", logitsDimension)
-  let _ = op.addInput(treeEnsembleHandle)
-  let _ = op.addInput(cachedTreeIds)
-  let _ = op.addInput(cachedNodeIds)
-  let _ = op.addInputList(bucketizedFeatures)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Updates the tree ensemble by either adding a layer to the last tree being grown
-///
-/// or by starting a new tree.
-///
-/// - Parameters:
-///   - tree_ensemble_handle: Handle to the ensemble variable.
-///   - feature_ids: Rank 1 tensor with ids for each feature. This is the real id of
-///     the feature that will be used in the split.
-///   - node_ids: List of rank 1 tensors representing the nodes for which this feature
-///     has a split.
-///   - gains: List of rank 1 tensors representing the gains for each of the feature's
-///     split.
-///   - thresholds: List of rank 1 tensors representing the thesholds for each of the
-///     feature's split.
-///   - left_node_contribs: List of rank 2 tensors with left leaf contribs for each of
-///     the feature's splits. Will be added to the previous node values to constitute
-///     the values of the left nodes.
-///   - right_node_contribs: List of rank 2 tensors with right leaf contribs for each
-///     of the feature's splits. Will be added to the previous node values to constitute
-///     the values of the right nodes.
-///   - max_depth: Max depth of the tree to build.
-///   - learning_rate: shrinkage const for each new tree.
-///
-/// - Attrs:
-///   - pruning_mode: 0-No pruning, 1-Pre-pruning, 2-Post-pruning.
-///   - num_features: Number of features that have best splits returned. INFERRED.
-@inlinable
-public static func boostedTreesUpdateEnsemble(
-  treeEnsembleHandle: ResourceHandle,
-  featureIds: Tensor<Int32>,
-  nodeIds: [Tensor<Int32>],
-  gains: [Tensor<Float>],
-  thresholds: [Tensor<Int32>],
-  leftNodeContribs: [Tensor<Float>],
-  rightNodeContribs: [Tensor<Float>],
-  maxDepth: Tensor<Int32>,
-  learningRate: Tensor<Float>,
-  pruningMode: Int64
-) {
-  let op = TFE_Op("BoostedTreesUpdateEnsemble")
-  op.setAttr("pruning_mode", pruningMode)
-  op.setAttr("num_features", nodeIds.count)
-  let _ = op.addInput(treeEnsembleHandle)
-  let _ = op.addInput(featureIds)
-  let _ = op.addInputList(nodeIds)
-  let _ = op.addInputList(gains)
-  let _ = op.addInputList(thresholds)
-  let _ = op.addInputList(leftNodeContribs)
-  let _ = op.addInputList(rightNodeContribs)
-  let _ = op.addInput(maxDepth)
-  let _ = op.addInput(learningRate)
-  op.execute()
-}
-
-/// Return the shape of s0 op s1 with broadcast.
-///
-/// Given `s0` and `s1`, tensors that represent shapes, compute `r0`, the
-/// broadcasted shape. `s0`, `s1` and `r0` are all integer vectors.
-@inlinable
-public static func broadcastArgs<T: BinaryInteger & TensorFlowScalar>(
-  s0: Tensor<T>,
-  s1: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("BroadcastArgs")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(s0)
-  let _ = op.addInput(s1)
-  return op.execute(Int(1))
-}
-
-/// Return the reduction indices for computing gradients of s0 op s1 with broadcast.
-///
-/// This is typically used by gradient computations for a broadcasting operation.
-@inlinable
-public static func broadcastGradientArgs<T: BinaryInteger & TensorFlowScalar>(
-  s0: Tensor<T>,
-  s1: Tensor<T>
-) -> (r0: Tensor<T>, r1: Tensor<T>) {
-  let op = TFE_Op("BroadcastGradientArgs")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(s0)
-  let _ = op.addInput(s1)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Broadcast an array for a compatible shape.
-///
-/// Broadcasting is the process of making arrays to have compatible shapes
-/// for arithmetic operations. Two shapes are compatible if for each
-/// dimension pair they are either equal or one of them is one. When trying
-/// to broadcast a Tensor to a shape, it starts with the trailing dimensions,
-/// and works its way forward.
-///
-/// For example,
-/// ```
-/// >>> x = tf.constant([1, 2, 3])
-/// >>> y = tf.broadcast_to(x, [3, 3])
-/// >>> sess.run(y)
-/// array([[1, 2, 3],
-///        [1, 2, 3],
-///        [1, 2, 3]], dtype=int32)
-/// ```
-/// In the above example, the input Tensor with the shape of `[1, 3]`
-/// is broadcasted to output Tensor with shape of `[3, 3]`.
-///
-/// - Parameters:
-///   - input: A Tensor to broadcast.
-///   - shape: An 1-D `int` Tensor. The shape of the desired output.
-///
-/// - Output output: A Tensor.
-@inlinable
-public static func broadcastTo<
-    T: TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  shape: Tensor<Tidx>
-) -> Tensor<T> {
-  let op = TFE_Op("BroadcastTo")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Bucketizes 'input' based on 'boundaries'.
-///
-/// For example, if the inputs are
-///     boundaries = [0, 10, 100]
-///     input = [[-5, 10000]
-///              [150,   10]
-///              [5,    100]]
-///
-/// then the output will be
-///     output = [[0, 3]
-///               [3, 2]
-///               [1, 3]]
-///
-/// - Parameter input: Any shape of Tensor contains with int or float type.
-///
-/// - Attr boundaries: A sorted list of floats gives the boundary of the buckets.
-///
-/// - Output output: Same shape with 'input', each value of input replaced with bucket index.
-///
-///   @compatibility(numpy)
-///   Equivalent to np.digitize.
-///   @end_compatibility
-@inlinable
-public static func bucketize<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  boundaries: [Double]
-) -> Tensor<Int32> {
-  let op = TFE_Op("Bucketize")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("boundaries", boundaries)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Performs beam search decoding on the logits given in input.
-///
-/// A note about the attribute merge_repeated: For the beam search decoder,
-/// this means that if consecutive entries in a beam are the same, only
-/// the first of these is emitted.  That is, when the top path is "A B B B B",
-/// "A B" is returned if merge_repeated = True but "A B B B B" is
-/// returned if merge_repeated = False.
-///
-/// - Parameters:
-///   - inputs: 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
-///   - sequence_length: A vector containing sequence lengths, size `(batch)`.
-///
-/// - Attrs:
-///   - beam_width: A scalar >= 0 (beam search beam width).
-///   - top_paths: A scalar >= 0, <= beam_width (controls output size).
-///   - merge_repeated: If true, merge repeated classes in output.
-///
-/// - Outputs:
-///   - decoded_indices: A list (length: top_paths) of indices matrices.  Matrix j,
-///     size `(total_decoded_outputs[j] x 2)`, has indices of a
-///     `SparseTensor<int64, 2>`.  The rows store: [batch, time].
-///   - decoded_values: A list (length: top_paths) of values vectors.  Vector j,
-///     size `(length total_decoded_outputs[j])`, has the values of a
-///     `SparseTensor<int64, 2>`.  The vector stores the decoded classes for beam j.
-///   - decoded_shape: A list (length: top_paths) of shape vector.  Vector j,
-///     size `(2)`, stores the shape of the decoded `SparseTensor[j]`.
-///     Its values are: `[batch_size, max_decoded_length[j]]`.
-///   - log_probability: A matrix, shaped: `(batch_size x top_paths)`.  The
-///     sequence log-probabilities.
-@inlinable
-public static func cTCBeamSearchDecoder(
-  inputs: Tensor<Float>,
-  sequenceLength: Tensor<Int32>,
-  beamWidth: Int64,
-  topPaths: Int64,
-  mergeRepeated: Bool = true
-) -> (decodedIndices: [Tensor<Int64>], decodedValues: [Tensor<Int64>], decodedShape: [Tensor<Int64>], logProbability: Tensor<Float>) {
-  let op = TFE_Op("CTCBeamSearchDecoder")
-  op.setAttr("beam_width", beamWidth)
-  op.setAttr("top_paths", topPaths)
-  op.setAttr("merge_repeated", mergeRepeated)
-  let _ = op.addInput(inputs)
-  let _ = op.addInput(sequenceLength)
-  return op.execute(Int(topPaths), Int(topPaths), Int(topPaths), Int(1))
-}
-
-/// Performs greedy decoding on the logits given in inputs.
-///
-/// A note about the attribute merge_repeated: if enabled, when
-/// consecutive logits' maximum indices are the same, only the first of
-/// these is emitted.  Labeling the blank '*', the sequence "A B B * B B"
-/// becomes "A B B" if merge_repeated = True and "A B B B B" if
-/// merge_repeated = False.
-///
-/// Regardless of the value of merge_repeated, if the maximum index of a given
-/// time and batch corresponds to the blank, index `(num_classes - 1)`, no new
-/// element is emitted.
-///
-/// - Parameters:
-///   - inputs: 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
-///   - sequence_length: A vector containing sequence lengths, size `(batch_size)`.
-///
-/// - Attr merge_repeated: If True, merge repeated classes in output.
-///
-/// - Outputs:
-///   - decoded_indices: Indices matrix, size `(total_decoded_outputs x 2)`,
-///     of a `SparseTensor<int64, 2>`.  The rows store: [batch, time].
-///   - decoded_values: Values vector, size: `(total_decoded_outputs)`,
-///     of a `SparseTensor<int64, 2>`.  The vector stores the decoded classes.
-///   - decoded_shape: Shape vector, size `(2)`, of the decoded SparseTensor.
-///     Values are: `[batch_size, max_decoded_length]`.
-///   - log_probability: Matrix, size `(batch_size x 1)`, containing sequence
-///     log-probabilities.
-@inlinable
-public static func cTCGreedyDecoder(
-  inputs: Tensor<Float>,
-  sequenceLength: Tensor<Int32>,
-  mergeRepeated: Bool = false
-) -> (decodedIndices: Tensor<Int64>, decodedValues: Tensor<Int64>, decodedShape: Tensor<Int64>, logProbability: Tensor<Float>) {
-  let op = TFE_Op("CTCGreedyDecoder")
-  op.setAttr("merge_repeated", mergeRepeated)
-  let _ = op.addInput(inputs)
-  let _ = op.addInput(sequenceLength)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Calculates the CTC Loss (log probability) for each batch entry.  Also calculates
-///
-/// the gradient.  This class performs the softmax operation for you, so inputs
-/// should be e.g. linear projections of outputs by an LSTM.
-///
-/// - Parameters:
-///   - inputs: 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
-///   - labels_indices: The indices of a `SparseTensor<int32, 2>`.
-///     `labels_indices(i, :) == [b, t]` means `labels_values(i)` stores the id for
-///     `(batch b, time t)`.
-///   - labels_values: The values (labels) associated with the given batch and time.
-///   - sequence_length: A vector containing sequence lengths (batch).
-///
-/// - Attrs:
-///   - preprocess_collapse_repeated: Scalar, if true then repeated labels are
-///     collapsed prior to the CTC calculation.
-///   - ctc_merge_repeated: Scalar.  If set to false, *during* CTC calculation
-///     repeated non-blank labels will not be merged and are interpreted as
-///     individual labels.  This is a simplified version of CTC.
-///   - ignore_longer_outputs_than_inputs: Scalar. If set to true, during CTC
-///     calculation, items that have longer output sequences than input sequences
-///     are skipped: they don't contribute to the loss term and have zero-gradient.
-///
-/// - Outputs:
-///   - loss: A vector (batch) containing log-probabilities.
-///   - gradient: The gradient of `loss`.  3-D, shape:
-///     `(max_time x batch_size x num_classes)`.
-@inlinable
-public static func cTCLoss(
-  inputs: Tensor<Float>,
-  labelsIndices: Tensor<Int64>,
-  labelsValues: Tensor<Int32>,
-  sequenceLength: Tensor<Int32>,
-  preprocessCollapseRepeated: Bool = false,
-  ctcMergeRepeated: Bool = true,
-  ignoreLongerOutputsThanInputs: Bool = false
-) -> (loss: Tensor<Float>, gradient: Tensor<Float>) {
-  let op = TFE_Op("CTCLoss")
-  op.setAttr("preprocess_collapse_repeated", preprocessCollapseRepeated)
-  op.setAttr("ctc_merge_repeated", ctcMergeRepeated)
-  op.setAttr("ignore_longer_outputs_than_inputs", ignoreLongerOutputsThanInputs)
-  let _ = op.addInput(inputs)
-  let _ = op.addInput(labelsIndices)
-  let _ = op.addInput(labelsValues)
-  let _ = op.addInput(sequenceLength)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Creates a dataset that caches elements from `input_dataset`.
-///
-/// A CacheDataset will iterate over the input_dataset, and store tensors. If the
-/// cache already exists, the cache will be used. If the cache is inappropriate
-/// (e.g. cannot be opened, contains tensors of the wrong shape / size), an error
-/// will the returned when used.
-///
-/// - Parameter filename: A path on the filesystem where we should cache the dataset. Note: this
-///   will be a directory.
-@inlinable
-public static func cacheDataset(
-  inputDataset: VariantHandle,
-  filename: StringTensor,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("CacheDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(filename)
-  return op.execute(Int(1))
-}
-
-/// Cast x of type SrcT to y of DstT.
-@inlinable
-public static func cast<
-    Srct: TensorFlowScalar,
-    Dstt: TensorFlowScalar
->(
-  _ x: Tensor<Srct>,
-  truncate: Bool = false
-) -> Tensor<Dstt> {
-  let op = TFE_Op("Cast")
-  op.setAttr("SrcT", Srct.tensorFlowDataType)
-  op.setAttr("DstT", Dstt.tensorFlowDataType)
-  op.setAttr("Truncate", truncate)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns element-wise smallest integer not less than x.
-@inlinable
-public static func ceil<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Ceil")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// 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.
-///
-/// - Attr message: Prefix of the error message.
-@inlinable
-public static func checkNumerics<T: FloatingPoint & TensorFlowScalar>(
-  _ tensor: Tensor<T>,
-  message: String
-) -> Tensor<T> {
-  let op = TFE_Op("CheckNumerics")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("message", message)
-  let _ = op.addInput(tensor)
-  return op.execute(Int(1))
-}
-
-/// Computes the Cholesky decomposition of one or more square matrices.
-///
-/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-/// form square matrices.
-///
-/// The input has to be symmetric and positive definite. Only the lower-triangular
-/// part of the input will be used for this operation. The upper-triangular part
-/// will not be read.
-///
-/// The output is a tensor of the same shape as the input
-/// containing the Cholesky decompositions for all input submatrices `[..., :, :]`.
-///
-/// **Note**: The gradient computation on GPU is faster for large matrices but
-/// not for large batch dimensions when the submatrices are small. In this
-/// case it might be faster to use the CPU.
-///
-/// - Parameter input: Shape is `[..., M, M]`.
-///
-/// - Output output: Shape is `[..., M, M]`.
-@inlinable
-public static func cholesky<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Cholesky")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Computes the reverse mode backpropagated gradient of the Cholesky algorithm.
-///
-/// For an explanation see "Differentiation of the Cholesky algorithm" by
-/// Iain Murray http://arxiv.org/abs/1602.07527.
-///
-/// - Parameters:
-///   - l: Output of batch Cholesky algorithm l = cholesky(A). Shape is `[..., M, M]`.
-///     Algorithm depends only on lower triangular part of the innermost matrices of
-///     this tensor.
-///   - grad: df/dl where f is some scalar function. Shape is `[..., M, M]`.
-///     Algorithm depends only on lower triangular part of the innermost matrices of
-///     this tensor.
-///
-/// - Output output: Symmetrized version of df/dA . Shape is `[..., M, M]`
-@inlinable
-public static func choleskyGrad<T: FloatingPoint & TensorFlowScalar>(
-  l: Tensor<T>,
-  grad: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("CholeskyGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(l)
-  let _ = op.addInput(grad)
-  return op.execute(Int(1))
-}
-
-/// Clips tensor values to a specified min and max.
-///
-/// Given a tensor `t`, this operation returns a tensor of the same type and
-/// shape as `t` with its values clipped to `clip_value_min` and `clip_value_max`.
-/// Any values less than `clip_value_min` are set to `clip_value_min`. Any values
-/// greater than `clip_value_max` are set to `clip_value_max`.
-///
-/// - Parameters:
-///   - t: A `Tensor`.
-///   - clip_value_min: A 0-D (scalar) `Tensor`, or a `Tensor` with the same shape
-///     as `t`. The minimum value to clip by.
-///   - clip_value_max: A 0-D (scalar) `Tensor`, or a `Tensor` with the same shape
-///     as `t`. The maximum value to clip by.
-///
-/// - Output output: A clipped `Tensor` with the same shape as input 't'.
-@inlinable
-public static func clipByValue<T: Numeric & TensorFlowScalar>(
-  t: Tensor<T>,
-  clipValueMin: Tensor<T>,
-  clipValueMax: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("ClipByValue")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(t)
-  let _ = op.addInput(clipValueMin)
-  let _ = op.addInput(clipValueMax)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func closeSummaryWriter(
-  writer: ResourceHandle
-) {
-  let op = TFE_Op("CloseSummaryWriter")
-  let _ = op.addInput(writer)
-  op.execute()
-}
-
-/// Receives a tensor value broadcast from another device.
-@inlinable
-public static func collectiveBcastRecv<T: Numeric & TensorFlowScalar>(
-  groupSize: Int64,
-  groupKey: Int64,
-  instanceKey: Int64,
-  shape: TensorShape?
-) -> Tensor<T> {
-  let op = TFE_Op("CollectiveBcastRecv")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("group_size", groupSize)
-  op.setAttr("group_key", groupKey)
-  op.setAttr("instance_key", instanceKey)
-  op.setAttr("shape", shape)
-  return op.execute(Int(1))
-}
-
-/// Broadcasts a tensor value to one or more other devices.
-@inlinable
-public static func collectiveBcastSend<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  groupSize: Int64,
-  groupKey: Int64,
-  instanceKey: Int64,
-  shape: TensorShape?
-) -> Tensor<T> {
-  let op = TFE_Op("CollectiveBcastSend")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("group_size", groupSize)
-  op.setAttr("group_key", groupKey)
-  op.setAttr("instance_key", instanceKey)
-  op.setAttr("shape", shape)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Mutually accumulates multiple tensors of identical type and shape.
-@inlinable
-public static func collectiveGather<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  groupSize: Int64,
-  groupKey: Int64,
-  instanceKey: Int64,
-  shape: TensorShape?
-) -> Tensor<T> {
-  let op = TFE_Op("CollectiveGather")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("group_size", groupSize)
-  op.setAttr("group_key", groupKey)
-  op.setAttr("instance_key", instanceKey)
-  op.setAttr("shape", shape)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// An Op to permute tensors across replicated TPU instances.
-///
-/// Each instance supplies its own input.
-///
-/// For example, suppose there are 4 TPU instances: `[A, B, C, D]`. Passing
-/// source_target_pairs=`[[0,1],[1,2],[2,3],[3,0]]` gets the outputs:
-/// `[D, A, B, C]`.
-///
-/// - Parameters:
-///   - input: The local input to be permuted. Currently only supports float and
-///     bfloat16.
-///   - source_target_pairs: A tensor with shape [num_pairs, 2].
-///
-/// - Attr T: The type of elements to be exchanged.
-///
-/// - Output output: The permuted input.
-@inlinable
-public static func collectivePermute<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  sourceTargetPairs: Tensor<Int32>
-) -> Tensor<T> {
-  let op = TFE_Op("CollectivePermute")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(sourceTargetPairs)
-  return op.execute(Int(1))
-}
-
-/// Mutually reduces multiple tensors of identical type and shape.
-@inlinable
-public static func collectiveReduce<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  groupSize: Int64,
-  groupKey: Int64,
-  instanceKey: Int64,
-  mergeOp: MergeOp,
-  finalOp: FinalOp,
-  subdivOffsets: [Int32],
-  waitFor: [Int32]
-) -> Tensor<T> {
-  let op = TFE_Op("CollectiveReduce")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("group_size", groupSize)
-  op.setAttr("group_key", groupKey)
-  op.setAttr("instance_key", instanceKey)
-  op.setAttr("merge_op", mergeOp.cName)
-  op.setAttr("final_op", finalOp.cName)
-  op.setAttr("subdiv_offsets", subdivOffsets)
-  op.setAttr("wait_for", waitFor)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Greedily selects a subset of bounding boxes in descending order of score,
-///
-/// This operation performs non_max_suppression on the inputs per batch, across
-/// all classes.
-/// Prunes away boxes that have high intersection-over-union (IOU) overlap
-/// with previously selected boxes.  Bounding boxes are supplied as
-/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
-/// diagonal pair of box corners and the coordinates can be provided as normalized
-/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
-/// is agnostic to where the origin is in the coordinate system. Also note that
-/// this algorithm is invariant to orthogonal transformations and translations
-/// of the coordinate system; thus translating or reflections of the coordinate
-/// system result in the same boxes being selected by the algorithm.
-/// The output of this operation is the final boxes, scores and classes tensor
-/// returned after performing non_max_suppression.
-///
-/// - Parameters:
-///   - boxes: A 4-D float tensor of shape `[batch_size, num_boxes, q, 4]`. If `q` is 1 then 
-///     same boxes are used for all classes otherwise, if `q` is equal to number of 
-///     classes, class-specific boxes are used.
-///   - scores: A 3-D float tensor of shape `[batch_size, num_boxes, num_classes]`
-///     representing a single score corresponding to each box (each row of boxes).
-///   - max_output_size_per_class: A scalar integer tensor representing the maximum number of 
-///     boxes to be selected by non max suppression per class
-///   - max_total_size: A scalar representing maximum number of boxes retained over all classes.
-///   - iou_threshold: A 0-D float tensor representing the threshold for deciding whether
-///     boxes overlap too much with respect to IOU.
-///   - score_threshold: A 0-D float tensor representing the threshold for deciding when to remove
-///     boxes based on score.
-///
-/// - Attrs:
-///   - pad_per_class: If false, the output nmsed boxes, scores and classes
-///     are padded/clipped to `max_total_size`. If true, the
-///     output nmsed boxes, scores and classes are padded to be of length
-///     `max_size_per_class`*`num_classes`, unless it exceeds `max_total_size` in
-///     which case it is clipped to `max_total_size`. Defaults to false.
-///   - clip_boxes: If true, assume the box coordinates are between [0, 1] and clip the output boxes
-///     if they fall beyond [0, 1]. If false, do not do clipping and output the box
-///     coordinates as it is.
-///
-/// - Outputs:
-///   - nmsed_boxes: A [batch_size, max_detections, 4] float32 tensor 
-///     containing the non-max suppressed boxes.
-///   - nmsed_scores: A [batch_size, max_detections] float32 tensor 
-///     containing the scores for the boxes.
-///   - nmsed_classes: A [batch_size, max_detections] float32 tensor 
-///     containing the classes for the boxes.
-///   - valid_detections: A [batch_size] int32 tensor indicating the number of
-///     valid detections per batch item. Only the top num_detections[i] entries in
-///     nms_boxes[i], nms_scores[i] and nms_class[i] are valid. The rest of the
-///     entries are zero paddings.
-@inlinable
-public static func combinedNonMaxSuppression(
-  boxes: Tensor<Float>,
-  scores: Tensor<Float>,
-  maxOutputSizePerClass: Tensor<Int32>,
-  maxTotalSize: Tensor<Int32>,
-  iouThreshold: Tensor<Float>,
-  scoreThreshold: Tensor<Float>,
-  padPerClass: Bool = false,
-  clipBoxes: Bool = true
-) -> (nmsedBoxes: Tensor<Float>, nmsedScores: Tensor<Float>, nmsedClasses: Tensor<Float>, validDetections: Tensor<Int32>) {
-  let op = TFE_Op("CombinedNonMaxSuppression")
-  op.setAttr("pad_per_class", padPerClass)
-  op.setAttr("clip_boxes", clipBoxes)
-  let _ = op.addInput(boxes)
-  let _ = op.addInput(scores)
-  let _ = op.addInput(maxOutputSizePerClass)
-  let _ = op.addInput(maxTotalSize)
-  let _ = op.addInput(iouThreshold)
-  let _ = op.addInput(scoreThreshold)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Compare values of `input` to `threshold` and pack resulting bits into a `uint8`.
-///
-/// Each comparison returns a boolean `true` (if `input_value > threshold`)
-/// or and `false` otherwise.
-///
-/// This operation is useful for Locality-Sensitive-Hashing (LSH) and other
-/// algorithms that use hashing approximations of cosine and `L2` distances;
-/// codes can be generated from an input via:
-///
-/// ```python
-/// codebook_size = 50
-/// codebook_bits = codebook_size * 32
-/// codebook = tf.get_variable('codebook', [x.shape[-1].value, codebook_bits],
-///                            dtype=x.dtype,
-///                            initializer=tf.orthogonal_initializer())
-/// codes = compare_and_threshold(tf.matmul(x, codebook), threshold=0.)
-/// codes = tf.bitcast(codes, tf.int32)  # go from uint8 to int32
-/// # now codes has shape x.shape[:-1] + [codebook_size]
-/// ```
-///
-/// **NOTE**: Currently, the innermost dimension of the tensor must be divisible
-/// by 8.
-///
-/// Given an `input` shaped `[s0, s1, ..., s_n]`, the output is
-/// a `uint8` tensor shaped `[s0, s1, ..., s_n / 8]`.
-///
-/// - Parameters:
-///   - input: Values to compare against `threshold` and bitpack.
-///   - threshold: Threshold to compare against.
-///
-/// - Attr T: The type of the input and threshold.
-///
-/// - Output output: The bitpacked comparisons.
-@inlinable
-public static func compareAndBitpack<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  threshold: Tensor<T>
-) -> Tensor<UInt8> {
-  let op = TFE_Op("CompareAndBitpack")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(threshold)
-  return op.execute(Int(1))
-}
-
-/// Converts two real numbers to a complex number.
-///
-/// Given a tensor `real` representing the real part of a complex number, and a
-/// tensor `imag` representing the imaginary part of a complex number, this
-/// operation returns complex numbers elementwise of the form \\(a + bj\\), where
-/// *a* represents the `real` part and *b* represents the `imag` part.
-///
-/// The input tensors `real` and `imag` must have the same shape.
-///
-/// For example:
-///
-/// ```
-/// # tensor 'real' is [2.25, 3.25]
-/// # tensor `imag` is [4.75, 5.75]
-/// tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]]
-/// ```
-@inlinable
-public static func complex<
-    T: FloatingPoint & TensorFlowScalar,
-    Tout: TensorFlowScalar
->(
-  real: Tensor<T>,
-  imag: Tensor<T>
-) -> Tensor<Tout> {
-  let op = TFE_Op("Complex")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tout", Tout.tensorFlowDataType)
-  let _ = op.addInput(real)
-  let _ = op.addInput(imag)
-  return op.execute(Int(1))
-}
-
-/// Computes the complex absolute value of a tensor.
-///
-/// Given a tensor `x` of complex numbers, this operation returns a tensor of type
-/// `float` or `double` that is the absolute value of each element in `x`. All
-/// elements in `x` must be complex numbers of the form \\(a + bj\\). The absolute
-/// value is computed as \\( \sqrt{a^2 + b^2}\\).
-@inlinable
-public static func complexAbs<
-    T: TensorFlowScalar,
-    Tout: FloatingPoint & TensorFlowScalar
->(
-  _ x: Tensor<T>
-) -> Tensor<Tout> {
-  let op = TFE_Op("ComplexAbs")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tout", Tout.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func complexStruct<TC: TensorGroup>(
-  nA: Int64,
-  nB: Int64
-) -> (a: [Tensor<Int32>], b: [Tensor<Int64>], c: TC) {
-  let op = TFE_Op("ComplexStruct")
-  op.setAttr("n_a", nA)
-  op.setAttr("n_b", nB)
-  op.setAttr("t_c", TC._typeList)
-  return op.execute(Int(nA), Int(nB), Int(TC._typeList.count))
-}
-
-/// Computes the ids of the positions in sampled_candidates that match true_labels.
-///
-/// When doing log-odds NCE, the result of this op should be passed through a
-/// SparseToDense op, then added to the logits of the sampled candidates. This has
-/// the effect of 'removing' the sampled labels that match the true labels by
-/// making the classifier sure that they are sampled labels.
-///
-/// - Parameters:
-///   - true_classes: The true_classes output of UnpackSparseLabels.
-///   - sampled_candidates: The sampled_candidates output of CandidateSampler.
-///
-/// - Attrs:
-///   - num_true: Number of true labels per context.
-///   - seed: If either seed or seed2 are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: An second seed to avoid seed collision.
-///
-/// - Outputs:
-///   - indices: A vector of indices corresponding to rows of true_candidates.
-///   - ids: A vector of IDs of positions in sampled_candidates that match a true_label
-///     for the row with the corresponding index in indices.
-///   - weights: A vector of the same length as indices and ids, in which each element
-///     is -FLOAT_MAX.
-@inlinable
-public static func computeAccidentalHits(
-  trueClasses: Tensor<Int64>,
-  sampledCandidates: Tensor<Int64>,
-  numTrue: Int64,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> (indices: Tensor<Int32>, ids: Tensor<Int64>, weights: Tensor<Float>) {
-  let op = TFE_Op("ComputeAccidentalHits")
-  op.setAttr("num_true", numTrue)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(trueClasses)
-  let _ = op.addInput(sampledCandidates)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Concatenates tensors along one dimension.
-///
-/// - Parameters:
-///   - concat_dim: 0-D.  The dimension along which to concatenate.  Must be in the
-///     range [0, rank(values)).
-///   - values: The `N` Tensors to concatenate. Their ranks and types must match,
-///     and their sizes must match in all dimensions except `concat_dim`.
-///
-/// - Output output: A `Tensor` with the concatenation of values stacked along the
-///   `concat_dim` dimension.  This tensor's shape matches that of `values` except
-///   in `concat_dim` where it has the sum of the sizes.
-@inlinable
-public static func concat<T: TensorFlowScalar>(
-  concatDim: Tensor<Int32>,
-  _ values: [Tensor<T>]
-) -> Tensor<T> {
-  let op = TFE_Op("Concat")
-  op.setAttr("N", values.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(concatDim)
-  let _ = op.addInputList(values)
-  return op.execute(Int(1))
-}
-
-/// Computes offsets of concat inputs within its output.
-///
-/// For example:
-///
-/// ```
-/// # 'x' is [2, 2, 7]
-/// # 'y' is [2, 3, 7]
-/// # 'z' is [2, 5, 7]
-/// concat_offset(2, [x, y, z]) => [0, 0, 0], [0, 2, 0], [0, 5, 0]
-/// ```
-///
-/// This is typically used by gradient computations for a concat operation.
-///
-/// - Parameters:
-///   - concat_dim: The dimension along which to concatenate.
-///   - shape: The `N` int32 vectors representing shape of tensors being concatenated.
-///
-/// - Output offset: The `N` int32 vectors representing the starting offset
-///   of input tensors within the concatenated output.
-@inlinable
-public static func concatOffset(
-  concatDim: Tensor<Int32>,
-  shape: [Tensor<Int32>]
-) -> [Tensor<Int32>] {
-  let op = TFE_Op("ConcatOffset")
-  op.setAttr("N", shape.count)
-  let _ = op.addInput(concatDim)
-  let _ = op.addInputList(shape)
-  return op.execute(Int(shape.count))
-}
-
-/// Concatenates tensors along one dimension.
-///
-/// - Parameters:
-///   - values: List of `N` Tensors to concatenate. Their ranks and types must match,
-///     and their sizes must match in all dimensions except `concat_dim`.
-///   - axis: 0-D.  The dimension along which to concatenate.  Must be in the
-///     range [-rank(values), rank(values)).
-///
-/// - Output output: A `Tensor` with the concatenation of values stacked along the
-///   `concat_dim` dimension.  This tensor's shape matches that of `values` except
-///   in `concat_dim` where it has the sum of the sizes.
-@inlinable
-public static func concatV2<
-    T: TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  _ values: [Tensor<T>],
-  axis: Tensor<Tidx>
-) -> Tensor<T> {
-  let op = TFE_Op("ConcatV2")
-  op.setAttr("N", values.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInputList(values)
-  let _ = op.addInput(axis)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that concatenates `input_dataset` with `another_dataset`.
-@inlinable
-public static func concatenateDataset(
-  inputDataset: VariantHandle,
-  anotherDataset: VariantHandle,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ConcatenateDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(anotherDataset)
-  return op.execute(Int(1))
-}
-
-/// Sets up the centralized structures for a distributed TPU system.
-///
-/// - Attrs:
-///   - embedding_config: Reserved. Do not use.
-///   - tpu_embedding_config: Serialized tensorflow.tpu.TPUEmbeddingConfiguration that
-///     describes the embedding lookups of the program.
-///   - is_global_init: Reserved. Do not use.
-///
-/// - Output topology: A serialized tensorflow.tpu.TopologyProto that describes the TPU
-///   topology.
-@inlinable
-public static func configureDistributedTPU(
-  embeddingConfig: String,
-  tpuEmbeddingConfig: String,
-  isGlobalInit: Bool = false
-) -> StringTensor {
-  let op = TFE_Op("ConfigureDistributedTPU")
-  op.setAttr("embedding_config", embeddingConfig)
-  op.setAttr("tpu_embedding_config", tpuEmbeddingConfig)
-  op.setAttr("is_global_init", isGlobalInit)
-  return op.execute(Int(1))
-}
-
-/// Returns the complex conjugate of a complex number.
-///
-/// Given a tensor `input` of complex numbers, this operation returns a tensor of
-/// complex numbers that are the complex conjugate of each element in `input`. The
-/// complex numbers in `input` must be of the form \\(a + bj\\), where *a* is the
-/// real part and *b* is the imaginary part.
-///
-/// The complex conjugate returned by this operation is of the form \\(a - bj\\).
-///
-/// For example:
-///
-/// ```
-/// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
-/// tf.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]
-/// ```
-@inlinable
-public static func conj<T: TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Conj")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Shuffle dimensions of x according to a permutation and conjugate the result.
-///
-/// The output `y` has the same rank as `x`. The shapes of `x` and `y` satisfy:
-///   `y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]`
-///   `y[i,j,k,...,s,t,u] == conj(x[perm[i], perm[j], perm[k],...,perm[s], perm[t], perm[u]])`
-@inlinable
-public static func conjugateTranspose<
-    T: TensorFlowScalar,
-    Tperm: BinaryInteger & TensorFlowScalar
->(
-  _ x: Tensor<T>,
-  perm: Tensor<Tperm>
-) -> Tensor<T> {
-  let op = TFE_Op("ConjugateTranspose")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tperm", Tperm.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(perm)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func constructionFails(
-) {
-  let op = TFE_Op("ConstructionFails")
-  
-  op.execute()
-}
-
-/// This op consumes a lock created by `MutexLock`.
-///
-/// This op exists to consume a tensor created by `MutexLock` (other than
-/// direct control dependencies).  It should be the only that consumes the tensor,
-/// and will raise an error if it is not.  Its only purpose is to keep the
-/// mutex lock tensor alive until it is consumed by this op.
-///
-/// **NOTE**: This operation must run on the same device as its input.  This may
-/// be enforced via the `colocate_with` mechanism.
-///
-/// - Parameter mutex_lock: A tensor returned by `MutexLock`.
-@inlinable
-public static func consumeMutexLock(
-  mutexLock: VariantHandle
-) {
-  let op = TFE_Op("ConsumeMutexLock")
-  let _ = op.addInput(mutexLock)
-  op.execute()
-}
-
-/// Does nothing. Serves as a control trigger for scheduling.
-///
-/// Only useful as a placeholder for control edges.
-@inlinable
-public static func controlTrigger(
-) {
-  let op = TFE_Op("ControlTrigger")
-  
-  op.execute()
-}
-
-/// Computes a 2-D convolution given 4-D `input` and `filter` tensors.
-///
-/// Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
-/// and a filter / kernel tensor of shape
-/// `[filter_height, filter_width, in_channels, out_channels]`, this op
-/// performs the following:
-///
-/// 1. Flattens the filter to a 2-D matrix with shape
-///    `[filter_height * filter_width * in_channels, output_channels]`.
-/// 2. Extracts image patches from the input tensor to form a *virtual*
-///    tensor of shape `[batch, out_height, out_width,
-///    filter_height * filter_width * in_channels]`.
-/// 3. For each patch, right-multiplies the filter matrix and the image patch
-///    vector.
-///
-/// In detail, with the default NHWC format,
-///
-///     output[b, i, j, k] =
-///         sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] *
-///                         filter[di, dj, q, k]
-///
-/// Must have `strides[0] = strides[3] = 1`.  For the most common case of the same
-/// horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
-///
-/// - Parameters:
-///   - input: A 4-D tensor. The dimension order is interpreted according to the value
-///     of `data_format`, see below for details.
-///   - filter: A 4-D tensor of shape
-///     `[filter_height, filter_width, in_channels, out_channels]`
-///
-/// - Attrs:
-///   - strides: 1-D tensor of length 4.  The stride of the sliding window for each
-///     dimension of `input`. The dimension order is determined by the value of
-///     `data_format`, see below for details.
-///   - padding: The type of padding algorithm to use.
-///   - explicit_paddings: If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
-///     dimension, the amount of padding inserted before and after the dimension is
-///     `explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
-///     `padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, height, width, channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, channels, height, width].
-///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
-///     `input`. If set to k > 1, there will be k-1 skipped cells between each
-///     filter element on that dimension. The dimension order is determined by the
-///     value of `data_format`, see above for details. Dilations in the batch and
-///     depth dimensions must be 1.
-///
-/// - Output output: A 4-D tensor. The dimension order is determined by the value of
-///   `data_format`, see below for details.
-@inlinable
-public static func conv2D<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  filter: Tensor<T>,
-  strides: [Int32],
-  useCudnnOnGpu: Bool = true,
-  padding: Padding2,
-  explicitPaddings: [Int32],
-  dataFormat: DataFormat = .nhwc,
-  dilations: [Int32] = [1, 1, 1, 1]
-) -> Tensor<T> {
-  let op = TFE_Op("Conv2D")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("use_cudnn_on_gpu", useCudnnOnGpu)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("explicit_paddings", explicitPaddings)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradients of convolution with respect to the filter.
-///
-/// - Parameters:
-///   - input: 4-D with shape `[batch, in_height, in_width, in_channels]`.
-///   - filter_sizes: An integer vector representing the tensor shape of `filter`,
-///     where `filter` is a 4-D
-///     `[filter_height, filter_width, in_channels, out_channels]` tensor.
-///   - out_backprop: 4-D with shape `[batch, out_height, out_width, out_channels]`.
-///     Gradients w.r.t. the output of the convolution.
-///
-/// - Attrs:
-///   - strides: The stride of the sliding window for each dimension of the input
-///     of the convolution. Must be in the same order as the dimension specified with
-///     format.
-///   - padding: The type of padding algorithm to use.
-///   - explicit_paddings: If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
-///     dimension, the amount of padding inserted before and after the dimension is
-///     `explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
-///     `padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, in_channels, in_height, in_width].
-///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
-///     `input`. If set to k > 1, there will be k-1 skipped cells between each filter
-///     element on that dimension. The dimension order is determined by the value of
-///     `data_format`, see above for details. Dilations in the batch and depth
-///     dimensions must be 1.
-///
-/// - Output output: 4-D with shape
-///   `[filter_height, filter_width, in_channels, out_channels]`.  Gradient w.r.t.
-///   the `filter` input of the convolution.
-@inlinable
-public static func conv2DBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  filterSizes: Tensor<Int32>,
-  outBackprop: Tensor<T>,
-  strides: [Int32],
-  useCudnnOnGpu: Bool = true,
-  padding: Padding2,
-  explicitPaddings: [Int32],
-  dataFormat: DataFormat = .nhwc,
-  dilations: [Int32] = [1, 1, 1, 1]
-) -> Tensor<T> {
-  let op = TFE_Op("Conv2DBackpropFilter")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("use_cudnn_on_gpu", useCudnnOnGpu)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("explicit_paddings", explicitPaddings)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filterSizes)
-  let _ = op.addInput(outBackprop)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradients of convolution with respect to the input.
-///
-/// - Parameters:
-///   - input_sizes: An integer vector representing the shape of `input`,
-///     where `input` is a 4-D `[batch, height, width, channels]` tensor.
-///   - filter: 4-D with shape
-///     `[filter_height, filter_width, in_channels, out_channels]`.
-///   - out_backprop: 4-D with shape `[batch, out_height, out_width, out_channels]`.
-///     Gradients w.r.t. the output of the convolution.
-///
-/// - Attrs:
-///   - strides: The stride of the sliding window for each dimension of the input
-///     of the convolution. Must be in the same order as the dimension specified with
-///     format.
-///   - padding: The type of padding algorithm to use.
-///   - explicit_paddings: If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
-///     dimension, the amount of padding inserted before and after the dimension is
-///     `explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
-///     `padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, in_channels, in_height, in_width].
-///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
-///     `input`. If set to k > 1, there will be k-1 skipped cells between each filter
-///     element on that dimension. The dimension order is determined by the value of
-///     `data_format`, see above for details. Dilations in the batch and depth
-///     dimensions must be 1.
-///
-/// - Output output: 4-D with shape `[batch, in_height, in_width, in_channels]`.  Gradient
-///   w.r.t. the input of the convolution.
-@inlinable
-public static func conv2DBackpropInput<T: FloatingPoint & TensorFlowScalar>(
-  inputSizes: Tensor<Int32>,
-  filter: Tensor<T>,
-  outBackprop: Tensor<T>,
-  strides: [Int32],
-  useCudnnOnGpu: Bool = true,
-  padding: Padding2,
-  explicitPaddings: [Int32],
-  dataFormat: DataFormat = .nhwc,
-  dilations: [Int32] = [1, 1, 1, 1]
-) -> Tensor<T> {
-  let op = TFE_Op("Conv2DBackpropInput")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("use_cudnn_on_gpu", useCudnnOnGpu)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("explicit_paddings", explicitPaddings)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(inputSizes)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(outBackprop)
-  return op.execute(Int(1))
-}
-
-/// Computes a 3-D convolution given 5-D `input` and `filter` tensors.
-///
-/// In signal processing, cross-correlation is a measure of similarity of
-/// two waveforms as a function of a time-lag applied to one of them. This
-/// is also known as a sliding dot product or sliding inner-product.
-///
-/// Our Conv3D implements a form of cross-correlation.
-///
-/// - Parameters:
-///   - input: Shape `[batch, in_depth, in_height, in_width, in_channels]`.
-///   - filter: Shape `[filter_depth, filter_height, filter_width, in_channels,
-///     out_channels]`. `in_channels` must match between `input` and `filter`.
-///
-/// - Attrs:
-///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
-///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: The data format of the input and output data. With the
-///     default format "NDHWC", the data is stored in the order of:
-///         [batch, in_depth, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCDHW", the data storage order is:
-///         [batch, in_channels, in_depth, in_height, in_width].
-///   - dilations: 1-D tensor of length 5.  The dilation factor for each dimension of
-///     `input`. If set to k > 1, there will be k-1 skipped cells between each
-///     filter element on that dimension. The dimension order is determined by the
-///     value of `data_format`, see above for details. Dilations in the batch and
-///     depth dimensions must be 1.
-@inlinable
-public static func conv3D<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  filter: Tensor<T>,
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat1 = .ndhwc,
-  dilations: [Int32] = [1, 1, 1, 1, 1]
-) -> Tensor<T> {
-  let op = TFE_Op("Conv3D")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradients of 3-D convolution with respect to the filter.
-///
-/// - Parameters:
-///   - input: Shape `[batch, depth, rows, cols, in_channels]`.
-///   - filter: Shape `[depth, rows, cols, in_channels, out_channels]`.
-///     `in_channels` must match between `input` and `filter`.
-///   - out_backprop: Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
-///     out_channels]`.
-///
-/// - Attrs:
-///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
-///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
-///   - padding: The type of padding algorithm to use.
-@inlinable
-public static func conv3DBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  filter: Tensor<T>,
-  outBackprop: Tensor<T>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1, 1]
-) -> Tensor<T> {
-  let op = TFE_Op("Conv3DBackpropFilter")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(outBackprop)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradients of 3-D convolution with respect to the filter.
-///
-/// - Parameters:
-///   - input: Shape `[batch, depth, rows, cols, in_channels]`.
-///   - filter_sizes: An integer vector representing the tensor shape of `filter`,
-///     where `filter` is a 5-D
-///     `[filter_depth, filter_height, filter_width, in_channels, out_channels]`
-///     tensor.
-///   - out_backprop: Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
-///     out_channels]`.
-///
-/// - Attrs:
-///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
-///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: The data format of the input and output data. With the
-///     default format "NDHWC", the data is stored in the order of:
-///         [batch, in_depth, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCDHW", the data storage order is:
-///         [batch, in_channels, in_depth, in_height, in_width].
-///   - dilations: 1-D tensor of length 5.  The dilation factor for each dimension of
-///     `input`. If set to k > 1, there will be k-1 skipped cells between each
-///     filter element on that dimension. The dimension order is determined by the
-///     value of `data_format`, see above for details. Dilations in the batch and
-///     depth dimensions must be 1.
-@inlinable
-public static func conv3DBackpropFilterV2<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  filterSizes: Tensor<Int32>,
-  outBackprop: Tensor<T>,
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat1 = .ndhwc,
-  dilations: [Int32] = [1, 1, 1, 1, 1]
-) -> Tensor<T> {
-  let op = TFE_Op("Conv3DBackpropFilterV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filterSizes)
-  let _ = op.addInput(outBackprop)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradients of 3-D convolution with respect to the input.
-///
-/// - Parameters:
-///   - input: Shape `[batch, depth, rows, cols, in_channels]`.
-///   - filter: Shape `[depth, rows, cols, in_channels, out_channels]`.
-///     `in_channels` must match between `input` and `filter`.
-///   - out_backprop: Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
-///     out_channels]`.
-///
-/// - Attrs:
-///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
-///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
-///   - padding: The type of padding algorithm to use.
-@inlinable
-public static func conv3DBackpropInput<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  filter: Tensor<T>,
-  outBackprop: Tensor<T>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1, 1]
-) -> Tensor<T> {
-  let op = TFE_Op("Conv3DBackpropInput")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(outBackprop)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradients of 3-D convolution with respect to the input.
-///
-/// - Parameters:
-///   - input_sizes: An integer vector representing the tensor shape of `input`,
-///     where `input` is a 5-D
-///     `[batch, depth, rows, cols, in_channels]` tensor.
-///   - filter: Shape `[depth, rows, cols, in_channels, out_channels]`.
-///     `in_channels` must match between `input` and `filter`.
-///   - out_backprop: Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
-///     out_channels]`.
-///
-/// - Attrs:
-///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
-///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: The data format of the input and output data. With the
-///     default format "NDHWC", the data is stored in the order of:
-///         [batch, in_depth, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCDHW", the data storage order is:
-///         [batch, in_channels, in_depth, in_height, in_width].
-///   - dilations: 1-D tensor of length 5.  The dilation factor for each dimension of
-///     `input`. If set to k > 1, there will be k-1 skipped cells between each
-///     filter element on that dimension. The dimension order is determined by the
-///     value of `data_format`, see above for details. Dilations in the batch and
-///     depth dimensions must be 1.
-@inlinable
-public static func conv3DBackpropInputV2<
-    T: FloatingPoint & TensorFlowScalar,
-    Tshape: BinaryInteger & TensorFlowScalar
->(
-  inputSizes: Tensor<Tshape>,
-  filter: Tensor<T>,
-  outBackprop: Tensor<T>,
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat1 = .ndhwc,
-  dilations: [Int32] = [1, 1, 1, 1, 1]
-) -> Tensor<T> {
-  let op = TFE_Op("Conv3DBackpropInputV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("dilations", dilations)
-  op.setAttr("Tshape", Tshape.tensorFlowDataType)
-  let _ = op.addInput(inputSizes)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(outBackprop)
-  return op.execute(Int(1))
-}
-
-/// Copy Op.
-///
-/// Performs CPU-to-CPU or GPU-to-GPU deep-copying of tensor, depending on the
-/// device on which the tensor is allocated.
-/// N.B.: If the all downstream attached debug ops are disabled given the current
-/// gRPC gating status, the output will simply forward the input tensor without
-/// deep-copying. See the documentation of Debug* ops for more details.
-///
-/// Unlike the CopyHost Op, this op does not have HostMemory constraint on its
-/// input or output.
-///
-/// - Parameter input: Input tensor.
-///
-/// - Attrs:
-///   - tensor_name: The name of the input tensor.
-///   - debug_ops_spec: A list of debug op spec (op, url, gated_grpc) for attached debug
-///     ops. Each element of the list has the format
-///     <debug_op>;<grpc_url>;<gated_grpc>, wherein gated_grpc is boolean represented
-///     as 0/1. E.g., "DebugIdentity;grpc://foo:3333;1",
-///     "DebugIdentity;file:///tmp/tfdbg_1;0".
-///
-/// - Output output: Output tensor, deep-copied from input.
-@inlinable
-public static func copy<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  tensorName: String,
-  debugOpsSpec: [String]
-) -> Tensor<T> {
-  let op = TFE_Op("Copy")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("tensor_name", tensorName)
-  op.setAttr("debug_ops_spec", debugOpsSpec)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Copy Host Op.
-///
-/// Performs CPU-to-CPU deep-copying of tensor.
-/// N.B.: If the all downstream attached debug ops are disabled given the current
-/// gRPC gating status, the output will simply forward the input tensor without
-/// deep-copying. See the documentation of Debug* ops for more details.
-///
-/// Unlike the Copy Op, this op has HostMemory constraint on its input or output.
-///
-/// - Parameter input: Input tensor.
-///
-/// - Attrs:
-///   - tensor_name: The name of the input tensor.
-///   - debug_ops_spec: A list of debug op spec (op, url, gated_grpc) for attached debug
-///     ops. Each element of the list has the format
-///     <debug_op>;<grpc_url>;<gated_grpc>, wherein gated_grpc is boolean represented
-///     as 0/1. E.g., "DebugIdentity;grpc://foo:3333;1",
-///     "DebugIdentity;file:///tmp/tfdbg_1;0".
-///
-/// - Output output: Output tensor, deep-copied from input.
-@inlinable
-public static func copyHost<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  tensorName: String,
-  debugOpsSpec: [String]
-) -> Tensor<T> {
-  let op = TFE_Op("CopyHost")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("tensor_name", tensorName)
-  op.setAttr("debug_ops_spec", debugOpsSpec)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func copyOp<T: TensorFlowScalar>(
-  _ a: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("CopyOp")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  return op.execute(Int(1))
-}
-
-/// Computes cos of x element-wise.
-@inlinable
-public static func cos<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Cos")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes hyperbolic cosine of x element-wise.
-@inlinable
-public static func cosh<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Cosh")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func createSummaryDbWriter(
-  writer: ResourceHandle,
-  dbUri: StringTensor,
-  experimentName: StringTensor,
-  runName: StringTensor,
-  userName: StringTensor
-) {
-  let op = TFE_Op("CreateSummaryDbWriter")
-  let _ = op.addInput(writer)
-  let _ = op.addInput(dbUri)
-  let _ = op.addInput(experimentName)
-  let _ = op.addInput(runName)
-  let _ = op.addInput(userName)
-  op.execute()
-}
-
-@inlinable
-public static func createSummaryFileWriter(
-  writer: ResourceHandle,
-  logdir: StringTensor,
-  maxQueue: Tensor<Int32>,
-  flushMillis: Tensor<Int32>,
-  filenameSuffix: StringTensor
-) {
-  let op = TFE_Op("CreateSummaryFileWriter")
-  let _ = op.addInput(writer)
-  let _ = op.addInput(logdir)
-  let _ = op.addInput(maxQueue)
-  let _ = op.addInput(flushMillis)
-  let _ = op.addInput(filenameSuffix)
-  op.execute()
-}
-
-/// Extracts crops from the input image tensor and resizes them.
-///
-/// Extracts crops from the input image tensor and resizes them using bilinear
-/// sampling or nearest neighbor sampling (possibly with aspect ratio change) to a
-/// common output size specified by `crop_size`. This is more general than the
-/// `crop_to_bounding_box` op which extracts a fixed size slice from the input image
-/// and does not allow resizing or aspect ratio change.
-///
-/// Returns a tensor with `crops` from the input `image` at positions defined at the
-/// bounding box locations in `boxes`. The cropped boxes are all resized (with
-/// bilinear or nearest neighbor interpolation) to a fixed
-/// `size = [crop_height, crop_width]`. The result is a 4-D tensor
-/// `[num_boxes, crop_height, crop_width, depth]`. The resizing is corner aligned.
-/// In particular, if `boxes = [[0, 0, 1, 1]]`, the method will give identical
-/// results to using `tf.image.resize_bilinear()` or
-/// `tf.image.resize_nearest_neighbor()`(depends on the `method` argument) with
-/// `align_corners=True`.
-///
-/// - Parameters:
-///   - image: A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
-///     Both `image_height` and `image_width` need to be positive.
-///   - boxes: A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
-///     specifies the coordinates of a box in the `box_ind[i]` image and is specified
-///     in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of
-///     `y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the
-///     `[0, 1]` interval of normalized image height is mapped to
-///     `[0, image_height - 1]` in image height coordinates. We do allow `y1` > `y2`, in
-///     which case the sampled crop is an up-down flipped version of the original
-///     image. The width dimension is treated similarly. Normalized coordinates
-///     outside the `[0, 1]` range are allowed, in which case we use
-///     `extrapolation_value` to extrapolate the input image values.
-///   - box_ind: A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
-///     The value of `box_ind[i]` specifies the image that the `i`-th box refers to.
-///   - crop_size: A 1-D tensor of 2 elements, `size = [crop_height, crop_width]`. All
-///     cropped image patches are resized to this size. The aspect ratio of the image
-///     content is not preserved. Both `crop_height` and `crop_width` need to be
-///     positive.
-///
-/// - Attrs:
-///   - method: A string specifying the sampling method for resizing. It can be either
-///     `"bilinear"` or `"nearest"` and default to `"bilinear"`. Currently two sampling
-///     methods are supported: Bilinear and Nearest Neighbor.
-///   - extrapolation_value: Value used for extrapolation, when applicable.
-///
-/// - Output crops: A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
-@inlinable
-public static func cropAndResize<T: Numeric & TensorFlowScalar>(
-  image: Tensor<T>,
-  boxes: Tensor<Float>,
-  boxInd: Tensor<Int32>,
-  cropSize: Tensor<Int32>,
-  method: Method = .bilinear,
-  extrapolationValue: Double = 0
-) -> Tensor<Float> {
-  let op = TFE_Op("CropAndResize")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("method", method.cName)
-  op.setAttr("extrapolation_value", extrapolationValue)
-  let _ = op.addInput(image)
-  let _ = op.addInput(boxes)
-  let _ = op.addInput(boxInd)
-  let _ = op.addInput(cropSize)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient of the crop_and_resize op wrt the input boxes tensor.
-///
-/// - Parameters:
-///   - grads: A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
-///   - image: A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
-///     Both `image_height` and `image_width` need to be positive.
-///   - boxes: A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
-///     specifies the coordinates of a box in the `box_ind[i]` image and is specified
-///     in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of
-///     `y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the
-///     `[0, 1]` interval of normalized image height is mapped to
-///     `[0, image_height - 1] in image height coordinates. We do allow y1 > y2, in
-///     which case the sampled crop is an up-down flipped version of the original
-///     image. The width dimension is treated similarly. Normalized coordinates
-///     outside the `[0, 1]` range are allowed, in which case we use
-///     `extrapolation_value` to extrapolate the input image values.
-///   - box_ind: A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
-///     The value of `box_ind[i]` specifies the image that the `i`-th box refers to.
-///
-/// - Attr method: A string specifying the interpolation method. Only 'bilinear' is
-///   supported for now.
-///
-/// - Output output: A 2-D tensor of shape `[num_boxes, 4]`.
-@inlinable
-public static func cropAndResizeGradBoxes<T: Numeric & TensorFlowScalar>(
-  grads: Tensor<Float>,
-  image: Tensor<T>,
-  boxes: Tensor<Float>,
-  boxInd: Tensor<Int32>,
-  method: Method3 = .bilinear
-) -> Tensor<Float> {
-  let op = TFE_Op("CropAndResizeGradBoxes")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("method", method.cName)
-  let _ = op.addInput(grads)
-  let _ = op.addInput(image)
-  let _ = op.addInput(boxes)
-  let _ = op.addInput(boxInd)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient of the crop_and_resize op wrt the input image tensor.
-///
-/// - Parameters:
-///   - grads: A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
-///   - boxes: A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
-///     specifies the coordinates of a box in the `box_ind[i]` image and is specified
-///     in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of
-///     `y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the
-///     `[0, 1]` interval of normalized image height is mapped to
-///     `[0, image_height - 1] in image height coordinates. We do allow y1 > y2, in
-///     which case the sampled crop is an up-down flipped version of the original
-///     image. The width dimension is treated similarly. Normalized coordinates
-///     outside the `[0, 1]` range are allowed, in which case we use
-///     `extrapolation_value` to extrapolate the input image values.
-///   - box_ind: A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
-///     The value of `box_ind[i]` specifies the image that the `i`-th box refers to.
-///   - image_size: A 1-D tensor with value `[batch, image_height, image_width, depth]`
-///     containing the original image size. Both `image_height` and `image_width` need
-///     to be positive.
-///
-/// - Attr method: A string specifying the interpolation method. Only 'bilinear' is
-///   supported for now.
-///
-/// - Output output: A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
-@inlinable
-public static func cropAndResizeGradImage<T: FloatingPoint & TensorFlowScalar>(
-  grads: Tensor<Float>,
-  boxes: Tensor<Float>,
-  boxInd: Tensor<Int32>,
-  imageSize: Tensor<Int32>,
-  method: Method = .bilinear
-) -> Tensor<T> {
-  let op = TFE_Op("CropAndResizeGradImage")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("method", method.cName)
-  let _ = op.addInput(grads)
-  let _ = op.addInput(boxes)
-  let _ = op.addInput(boxInd)
-  let _ = op.addInput(imageSize)
-  return op.execute(Int(1))
-}
-
-/// Compute the pairwise cross product.
-///
-/// `a` and `b` must be the same shape; they can either be simple 3-element vectors,
-/// or any shape where the innermost dimension is 3. In the latter case, each pair
-/// of corresponding 3-element vectors is cross-multiplied independently.
-///
-/// - Parameters:
-///   - a: A tensor containing 3-element vectors.
-///   - b: Another tensor, of same type and shape as `a`.
-///
-/// - Output product: Pairwise cross product of the vectors in `a` and `b`.
-@inlinable
-public static func cross<T: Numeric & TensorFlowScalar>(
-  _ a: Tensor<T>,
-  _ b: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Cross")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  return op.execute(Int(1))
-}
-
-/// An Op to sum inputs across replicated TPU instances.
-///
-/// Each instance supplies its own input.
-///
-/// For example, suppose there are 8 TPU instances: `[A, B, C, D, E, F, G, H]`.
-/// Passing group_assignment=`[[0,2,4,6],[1,3,5,7]]` sets `A, C, E, G` as group 0,
-/// and `B, D, F, H` as group 1. Thus we get the outputs:
-/// `[A+C+E+G, B+D+F+H, A+C+E+G, B+D+F+H, A+C+E+G, B+D+F+H, A+C+E+G, B+D+F+H]`.
-///
-/// - Parameters:
-///   - input: The local input to the sum.
-///   - group_assignment: An int32 tensor with shape
-///     [num_groups, num_replicas_per_group]. `group_assignment[i]` represents the
-///     replica ids in the ith subgroup.
-///
-/// - Attr T: The type of elements to be summed.
-///
-/// - Output output: The sum of all the distributed inputs.
-@inlinable
-public static func crossReplicaSum<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  groupAssignment: Tensor<Int32>
-) -> Tensor<T> {
-  let op = TFE_Op("CrossReplicaSum")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(groupAssignment)
-  return op.execute(Int(1))
-}
-
-/// A RNN backed by cuDNN.
-///
-/// Computes the RNN from the input and initial states, with respect to the params
-/// buffer.
-///
-/// rnn_mode: Indicates the type of the RNN model.
-/// input_mode: Indicate whether there is a linear projection between the input and
-///   the actual computation before the first layer. 'skip_input' is only allowed
-///   when input_size == num_units; 'auto_select' implies 'skip_input' when
-///   input_size == num_units; otherwise, it implies 'linear_input'.
-/// direction: Indicates whether a bidirectional model will be used. Should be
-///   "unidirectional" or "bidirectional".
-/// dropout: Dropout probability. When set to 0., dropout is disabled.
-/// seed: The 1st part of a seed to initialize dropout.
-/// seed2: The 2nd part of a seed to initialize dropout.
-/// input: A 3-D tensor with the shape of [seq_length, batch_size, input_size].
-/// input_h: A 3-D tensor with the shape of [num_layer * dir, batch_size,
-///     num_units].
-/// input_c: For LSTM, a 3-D tensor with the shape of
-///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
-/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
-///     The size must be created through CudnnRNNParamsSize, and initialized
-///     separately. Note that they might not be compatible across different
-///     generations. So it is a good idea to save and restore
-/// output: A 3-D tensor with the shape of [seq_length, batch_size,
-///     dir * num_units].
-/// output_h: The same shape has input_h.
-/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
-/// is_training: Indicates whether this operation is used for inferenece or
-///   training.
-/// reserve_space: An opaque tensor that can be used in backprop calculation. It
-///   is only produced if is_training is false.
-@inlinable
-public static func cudnnRNN<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  inputH: Tensor<T>,
-  inputC: Tensor<T>,
-  params: Tensor<T>,
-  rnnMode: RnnMode = .lstm,
-  inputMode: InputMode = .linearInput,
-  direction: Direction = .unidirectional,
-  dropout: Double = 0,
-  seed: Int64 = 0,
-  seed2: Int64 = 0,
-  isTraining: Bool = true
-) -> (output: Tensor<T>, outputH: Tensor<T>, outputC: Tensor<T>, reserveSpace: Tensor<T>) {
-  let op = TFE_Op("CudnnRNN")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("rnn_mode", rnnMode.cName)
-  op.setAttr("input_mode", inputMode.cName)
-  op.setAttr("direction", direction.cName)
-  op.setAttr("dropout", dropout)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("is_training", isTraining)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputH)
-  let _ = op.addInput(inputC)
-  let _ = op.addInput(params)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Backprop step of CudnnRNN.
-///
-/// Compute the backprop of both data and weights in a RNN.
-///
-/// rnn_mode: Indicates the type of the RNN model.
-/// input_mode: Indicate whether there is a linear projection between the input and
-///     the actual computation before the first layer. 'skip_input' is only allowed
-///     when input_size == num_units; 'auto_select' implies 'skip_input' when
-///     input_size == num_units; otherwise, it implies 'linear_input'.
-/// direction: Indicates whether a bidirectional model will be used. Should be
-///   "unidirectional" or "bidirectional".
-/// dropout: Dropout probability. When set to 0., dropout is disabled.
-/// seed: The 1st part of a seed to initialize dropout.
-/// seed2: The 2nd part of a seed to initialize dropout.
-/// input: A 3-D tensor with the shape of [seq_length, batch_size, input_size].
-/// input_h: A 3-D tensor with the shape of [num_layer * dir, batch_size,
-///     num_units].
-/// input_c: For LSTM, a 3-D tensor with the shape of
-///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
-/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
-///     The size must be created through CudnnRNNParamsSize, and initialized
-///     separately. Note that they might not be compatible across different
-///     generations. So it is a good idea to save and restore
-/// output: A 3-D tensor with the shape of [seq_length, batch_size,
-///     dir * num_units].
-/// output_h: The same shape has input_h.
-/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
-/// output_backprop: A 3-D tensor with the same shape as output in the forward pass.
-/// output_h_backprop: A 3-D tensor with the same shape as output_h in the forward
-///     pass.
-/// output_c_backprop: A 3-D tensor with the same shape as output_c in the forward
-///     pass.
-/// reserve_space: The same reserve_space produced in for forward operation.
-/// input_backprop: The backprop to input in the forward pass. Has the same shape
-///     as input.
-/// input_h_backprop: The backprop to input_h in the forward pass. Has the same
-///     shape as input_h.
-/// input_c_backprop: The backprop to input_c in the forward pass. Has the same
-///     shape as input_c.
-/// params_backprop: The backprop to the params buffer in the forward pass. Has the
-///     same shape as params.
-@inlinable
-public static func cudnnRNNBackprop<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  inputH: Tensor<T>,
-  inputC: Tensor<T>,
-  params: Tensor<T>,
-  output: Tensor<T>,
-  outputH: Tensor<T>,
-  outputC: Tensor<T>,
-  outputBackprop: Tensor<T>,
-  outputHBackprop: Tensor<T>,
-  outputCBackprop: Tensor<T>,
-  reserveSpace: Tensor<T>,
-  rnnMode: RnnMode = .lstm,
-  inputMode: InputMode = .linearInput,
-  direction: Direction = .unidirectional,
-  dropout: Double = 0,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> (inputBackprop: Tensor<T>, inputHBackprop: Tensor<T>, inputCBackprop: Tensor<T>, paramsBackprop: Tensor<T>) {
-  let op = TFE_Op("CudnnRNNBackprop")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("rnn_mode", rnnMode.cName)
-  op.setAttr("input_mode", inputMode.cName)
-  op.setAttr("direction", direction.cName)
-  op.setAttr("dropout", dropout)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputH)
-  let _ = op.addInput(inputC)
-  let _ = op.addInput(params)
-  let _ = op.addInput(output)
-  let _ = op.addInput(outputH)
-  let _ = op.addInput(outputC)
-  let _ = op.addInput(outputBackprop)
-  let _ = op.addInput(outputHBackprop)
-  let _ = op.addInput(outputCBackprop)
-  let _ = op.addInput(reserveSpace)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Backprop step of CudnnRNN.
-///
-/// Compute the backprop of both data and weights in a RNN. Takes an extra
-///     "host_reserved" inupt than CudnnRNNBackprop, which is used to determine RNN
-///     cudnnRNNAlgo_t and cudnnMathType_t.
-///
-/// rnn_mode: Indicates the type of the RNN model.
-/// input_mode: Indicates whether there is a linear projection between the input and
-///     the actual computation before the first layer. 'skip_input' is only allowed
-///     when input_size == num_units; 'auto_select' implies 'skip_input' when
-///     input_size == num_units; otherwise, it implies 'linear_input'.
-/// direction: Indicates whether a bidirectional model will be used. Should be
-///   "unidirectional" or "bidirectional".
-/// dropout: Dropout probability. When set to 0., dropout is disabled.
-/// seed: The 1st part of a seed to initialize dropout.
-/// seed2: The 2nd part of a seed to initialize dropout.
-/// input: A 3-D tensor with the shape of [seq_length, batch_size, input_size].
-/// input_h: A 3-D tensor with the shape of [num_layer * dir, batch_size,
-///     num_units].
-/// input_c: For LSTM, a 3-D tensor with the shape of
-///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
-/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
-///     The size must be created through CudnnRNNParamsSize, and initialized
-///     separately. Note that they might not be compatible across different
-///     generations. So it is a good idea to save and restore
-/// output: A 3-D tensor with the shape of [seq_length, batch_size,
-///     dir * num_units].
-/// output_h: The same shape has input_h.
-/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
-/// output_backprop: A 3-D tensor with the same shape as output in the forward pass.
-/// output_h_backprop: A 3-D tensor with the same shape as output_h in the forward
-///     pass.
-/// output_c_backprop: A 3-D tensor with the same shape as output_c in the forward
-///     pass.
-/// reserve_space: The same reserve_space produced in the forward operation.
-/// host_reserved: The same host_reserved produced in the forward operation.
-/// input_backprop: The backprop to input in the forward pass. Has the same shape
-///     as input.
-/// input_h_backprop: The backprop to input_h in the forward pass. Has the same
-///     shape as input_h.
-/// input_c_backprop: The backprop to input_c in the forward pass. Has the same
-///     shape as input_c.
-/// params_backprop: The backprop to the params buffer in the forward pass. Has the
-///     same shape as params.
-@inlinable
-public static func cudnnRNNBackpropV2<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  inputH: Tensor<T>,
-  inputC: Tensor<T>,
-  params: Tensor<T>,
-  output: Tensor<T>,
-  outputH: Tensor<T>,
-  outputC: Tensor<T>,
-  outputBackprop: Tensor<T>,
-  outputHBackprop: Tensor<T>,
-  outputCBackprop: Tensor<T>,
-  reserveSpace: Tensor<T>,
-  hostReserved: Tensor<Int8>,
-  rnnMode: RnnMode = .lstm,
-  inputMode: InputMode = .linearInput,
-  direction: Direction = .unidirectional,
-  dropout: Double = 0,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> (inputBackprop: Tensor<T>, inputHBackprop: Tensor<T>, inputCBackprop: Tensor<T>, paramsBackprop: Tensor<T>) {
-  let op = TFE_Op("CudnnRNNBackpropV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("rnn_mode", rnnMode.cName)
-  op.setAttr("input_mode", inputMode.cName)
-  op.setAttr("direction", direction.cName)
-  op.setAttr("dropout", dropout)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputH)
-  let _ = op.addInput(inputC)
-  let _ = op.addInput(params)
-  let _ = op.addInput(output)
-  let _ = op.addInput(outputH)
-  let _ = op.addInput(outputC)
-  let _ = op.addInput(outputBackprop)
-  let _ = op.addInput(outputHBackprop)
-  let _ = op.addInput(outputCBackprop)
-  let _ = op.addInput(reserveSpace)
-  let _ = op.addInput(hostReserved)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Backprop step of CudnnRNNV3.
-///
-/// Compute the backprop of both data and weights in a RNN. Takes an extra
-///     "sequence_lengths" input than CudnnRNNBackprop.
-///
-/// rnn_mode: Indicates the type of the RNN model.
-/// input_mode: Indicates whether there is a linear projection between the input and
-///     the actual computation before the first layer. 'skip_input' is only allowed
-///     when input_size == num_units; 'auto_select' implies 'skip_input' when
-///     input_size == num_units; otherwise, it implies 'linear_input'.
-/// direction: Indicates whether a bidirectional model will be used. Should be
-///   "unidirectional" or "bidirectional".
-/// dropout: Dropout probability. When set to 0., dropout is disabled.
-/// seed: The 1st part of a seed to initialize dropout.
-/// seed2: The 2nd part of a seed to initialize dropout.
-/// input: If time_major is true, this is a 3-D tensor with the shape of
-///     [seq_length, batch_size, input_size]. If time_major is false, the shape is
-///     [batch_size, seq_length, input_size].
-/// input_h: If time_major is true, this is a 3-D tensor with the shape of
-///     [num_layer * dir, batch_size, num_units]. If time_major is false, the shape
-///     is [batch_size, num_layer * dir, num_units].
-/// input_c: For LSTM, a 3-D tensor with the shape of
-///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
-/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
-///     The size must be created through CudnnRNNParamsSize, and initialized
-///     separately. Note that they might not be compatible across different
-///     generations. So it is a good idea to save and restore
-/// sequence_lengths: a vector of lengths of each input sequence.
-/// output: If time_major is true, this is a 3-D tensor with the shape of
-///     [seq_length, batch_size, dir * num_units]. If time_major is false, the
-///     shape is [batch_size, seq_length, dir * num_units].
-/// output_h: The same shape has input_h.
-/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
-/// output_backprop: A 3-D tensor with the same shape as output in the forward pass.
-/// output_h_backprop: A 3-D tensor with the same shape as output_h in the forward
-///     pass.
-/// output_c_backprop: A 3-D tensor with the same shape as output_c in the forward
-///     pass.
-/// time_major: Indicates whether the input/output format is time major or batch
-///     major.
-/// reserve_space: The same reserve_space produced in the forward operation.
-/// input_backprop: The backprop to input in the forward pass. Has the same shape
-///     as input.
-/// input_h_backprop: The backprop to input_h in the forward pass. Has the same
-///     shape as input_h.
-/// input_c_backprop: The backprop to input_c in the forward pass. Has the same
-///     shape as input_c.
-/// params_backprop: The backprop to the params buffer in the forward pass. Has the
-///     same shape as params.
-@inlinable
-public static func cudnnRNNBackpropV3<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  inputH: Tensor<T>,
-  inputC: Tensor<T>,
-  params: Tensor<T>,
-  sequenceLengths: Tensor<Int32>,
-  output: Tensor<T>,
-  outputH: Tensor<T>,
-  outputC: Tensor<T>,
-  outputBackprop: Tensor<T>,
-  outputHBackprop: Tensor<T>,
-  outputCBackprop: Tensor<T>,
-  reserveSpace: Tensor<T>,
-  hostReserved: Tensor<Int8>,
-  rnnMode: RnnMode = .lstm,
-  inputMode: InputMode = .linearInput,
-  direction: Direction = .unidirectional,
-  dropout: Double = 0,
-  seed: Int64 = 0,
-  seed2: Int64 = 0,
-  timeMajor: Bool = true
-) -> (inputBackprop: Tensor<T>, inputHBackprop: Tensor<T>, inputCBackprop: Tensor<T>, paramsBackprop: Tensor<T>) {
-  let op = TFE_Op("CudnnRNNBackpropV3")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("rnn_mode", rnnMode.cName)
-  op.setAttr("input_mode", inputMode.cName)
-  op.setAttr("direction", direction.cName)
-  op.setAttr("dropout", dropout)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("time_major", timeMajor)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputH)
-  let _ = op.addInput(inputC)
-  let _ = op.addInput(params)
-  let _ = op.addInput(sequenceLengths)
-  let _ = op.addInput(output)
-  let _ = op.addInput(outputH)
-  let _ = op.addInput(outputC)
-  let _ = op.addInput(outputBackprop)
-  let _ = op.addInput(outputHBackprop)
-  let _ = op.addInput(outputCBackprop)
-  let _ = op.addInput(reserveSpace)
-  let _ = op.addInput(hostReserved)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Converts CudnnRNN params from canonical form to usable form.
-///
-/// Writes a set of weights into the opaque params buffer so they can be used in
-/// upcoming training or inferences.
-///
-/// Note that the params buffer may not be compatible across different GPUs. So any
-/// save and restoration should be converted to and from the canonical weights and
-/// biases.
-///
-/// num_layers: Specifies the number of layers in the RNN model.
-/// num_units: Specifies the size of the hidden state.
-/// input_size: Specifies the size of the input state.
-/// weights: the canonical form of weights that can be used for saving
-///     and restoration. They are more likely to be compatible across different
-///     generations.
-/// biases: the canonical form of biases that can be used for saving
-///     and restoration. They are more likely to be compatible across different
-///     generations.
-/// num_params: number of parameter sets for all layers.
-///     Each layer may contain multiple parameter sets, with each set consisting of
-///     a weight matrix and a bias vector.
-/// rnn_mode: Indicates the type of the RNN model.
-/// input_mode: Indicate whether there is a linear projection between the input and
-///     The actual computation before the first layer. 'skip_input' is only allowed
-///     when input_size == num_units; 'auto_select' implies 'skip_input' when
-///     input_size == num_units; otherwise, it implies 'linear_input'.
-/// direction: Indicates whether a bidirectional model will be used.
-///     dir = (direction == bidirectional) ? 2 : 1
-/// dropout: dropout probability. When set to 0., dropout is disabled.
-/// seed: the 1st part of a seed to initialize dropout.
-/// seed2: the 2nd part of a seed to initialize dropout.
-@inlinable
-public static func cudnnRNNCanonicalToParams<T: FloatingPoint & TensorFlowScalar>(
-  numLayers: Tensor<Int32>,
-  numUnits: Tensor<Int32>,
-  inputSize: Tensor<Int32>,
-  weights: [Tensor<T>],
-  biases: [Tensor<T>],
-  rnnMode: RnnMode = .lstm,
-  inputMode: InputMode = .linearInput,
-  direction: Direction = .unidirectional,
-  dropout: Double = 0,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<T> {
-  let op = TFE_Op("CudnnRNNCanonicalToParams")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("num_params", weights.count)
-  op.setAttr("rnn_mode", rnnMode.cName)
-  op.setAttr("input_mode", inputMode.cName)
-  op.setAttr("direction", direction.cName)
-  op.setAttr("dropout", dropout)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(numLayers)
-  let _ = op.addInput(numUnits)
-  let _ = op.addInput(inputSize)
-  let _ = op.addInputList(weights)
-  let _ = op.addInputList(biases)
-  return op.execute(Int(1))
-}
-
-/// Computes size of weights that can be used by a Cudnn RNN model.
-///
-/// Return the params size that can be used by the Cudnn RNN model. Subsequent
-/// weight allocation and initialization should use this size.
-///
-/// num_layers: Specifies the number of layers in the RNN model.
-/// num_units: Specifies the size of the hidden state.
-/// input_size: Specifies the size of the input state.
-/// rnn_mode: Indicates the type of the RNN model.
-/// input_mode: Indicate whether there is a linear projection between the input and
-///   The actual computation before the first layer. 'skip_input' is only allowed
-///   when input_size == num_units; 'auto_select' implies 'skip_input' when
-///   input_size == num_units; otherwise, it implies 'linear_input'.
-/// direction: Indicates whether a bidirectional model will be used.
-///   dir = (direction == bidirectional) ? 2 : 1
-/// dropout: dropout probability. When set to 0., dropout is disabled.
-/// seed: the 1st part of a seed to initialize dropout.
-/// seed2: the 2nd part of a seed to initialize dropout.
-/// params_size: The size of the params buffer that should be allocated and
-///   initialized for this RNN model. Note that this params buffer may not be
-///   compatible across GPUs. Please use CudnnRNNParamsWeights and
-///   CudnnRNNParamsBiases to save and restore them in a way that is compatible
-///   across different runs.
-@inlinable
-public static func cudnnRNNParamsSize<S: BinaryInteger & TensorFlowScalar>(
-  numLayers: Tensor<Int32>,
-  numUnits: Tensor<Int32>,
-  inputSize: Tensor<Int32>,
-  t: TensorDataType,
-  rnnMode: RnnMode = .lstm,
-  inputMode: InputMode = .linearInput,
-  direction: Direction = .unidirectional,
-  dropout: Double = 0,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<S> {
-  let op = TFE_Op("CudnnRNNParamsSize")
-  op.setAttr("T", t)
-  op.setAttr("S", S.tensorFlowDataType)
-  op.setAttr("rnn_mode", rnnMode.cName)
-  op.setAttr("input_mode", inputMode.cName)
-  op.setAttr("direction", direction.cName)
-  op.setAttr("dropout", dropout)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(numLayers)
-  let _ = op.addInput(numUnits)
-  let _ = op.addInput(inputSize)
-  return op.execute(Int(1))
-}
-
-/// Retrieves CudnnRNN params in canonical form.
-///
-/// Retrieves a set of weights from the opaque params buffer that can be saved and
-/// restored in a way compatible with future runs.
-///
-/// Note that the params buffer may not be compatible across different GPUs. So any
-/// save and restoration should be converted to and from the canonical weights and
-/// biases.
-///
-/// num_layers: Specifies the number of layers in the RNN model.
-/// num_units: Specifies the size of the hidden state.
-/// input_size: Specifies the size of the input state.
-/// num_params: number of parameter sets for all layers.
-///     Each layer may contain multiple parameter sets, with each set consisting of
-///     a weight matrix and a bias vector.
-/// weights: the canonical form of weights that can be used for saving
-///     and restoration. They are more likely to be compatible across different
-///     generations.
-/// biases: the canonical form of biases that can be used for saving
-///     and restoration. They are more likely to be compatible across different
-///     generations.
-/// rnn_mode: Indicates the type of the RNN model.
-/// input_mode: Indicate whether there is a linear projection between the input and
-///     The actual computation before the first layer. 'skip_input' is only allowed
-///     when input_size == num_units; 'auto_select' implies 'skip_input' when
-///     input_size == num_units; otherwise, it implies 'linear_input'.
-/// direction: Indicates whether a bidirectional model will be used.
-///     dir = (direction == bidirectional) ? 2 : 1
-/// dropout: dropout probability. When set to 0., dropout is disabled.
-/// seed: the 1st part of a seed to initialize dropout.
-/// seed2: the 2nd part of a seed to initialize dropout.
-@inlinable
-public static func cudnnRNNParamsToCanonical<T: FloatingPoint & TensorFlowScalar>(
-  numLayers: Tensor<Int32>,
-  numUnits: Tensor<Int32>,
-  inputSize: Tensor<Int32>,
-  params: Tensor<T>,
-  numParams: Int64,
-  rnnMode: RnnMode = .lstm,
-  inputMode: InputMode = .linearInput,
-  direction: Direction = .unidirectional,
-  dropout: Double = 0,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> (weights: [Tensor<T>], biases: [Tensor<T>]) {
-  let op = TFE_Op("CudnnRNNParamsToCanonical")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("num_params", numParams)
-  op.setAttr("rnn_mode", rnnMode.cName)
-  op.setAttr("input_mode", inputMode.cName)
-  op.setAttr("direction", direction.cName)
-  op.setAttr("dropout", dropout)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(numLayers)
-  let _ = op.addInput(numUnits)
-  let _ = op.addInput(inputSize)
-  let _ = op.addInput(params)
-  return op.execute(Int(numParams), Int(numParams))
-}
-
-/// A RNN backed by cuDNN.
-///
-/// Computes the RNN from the input and initial states, with respect to the params
-/// buffer. Produces one extra output "host_reserved" than CudnnRNN.
-///
-/// rnn_mode: Indicates the type of the RNN model.
-/// input_mode: Indicates whether there is a linear projection between the input and
-///   the actual computation before the first layer. 'skip_input' is only allowed
-///   when input_size == num_units; 'auto_select' implies 'skip_input' when
-///   input_size == num_units; otherwise, it implies 'linear_input'.
-/// direction: Indicates whether a bidirectional model will be used. Should be
-///   "unidirectional" or "bidirectional".
-/// dropout: Dropout probability. When set to 0., dropout is disabled.
-/// seed: The 1st part of a seed to initialize dropout.
-/// seed2: The 2nd part of a seed to initialize dropout.
-/// input: A 3-D tensor with the shape of [seq_length, batch_size, input_size].
-/// input_h: A 3-D tensor with the shape of [num_layer * dir, batch_size,
-///     num_units].
-/// input_c: For LSTM, a 3-D tensor with the shape of
-///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
-/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
-///     The size must be created through CudnnRNNParamsSize, and initialized
-///     separately. Note that they might not be compatible across different
-///     generations. So it is a good idea to save and restore
-/// output: A 3-D tensor with the shape of [seq_length, batch_size,
-///     dir * num_units].
-/// output_h: The same shape has input_h.
-/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
-/// is_training: Indicates whether this operation is used for inferenece or
-///   training.
-/// reserve_space: An opaque tensor that can be used in backprop calculation. It
-///   is only produced if is_training is true.
-/// host_reserved: An opaque tensor that can be used in backprop calculation. It is
-///   only produced if is_training is true. It is output on host memory rather than
-///   device memory.
-@inlinable
-public static func cudnnRNNV2<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  inputH: Tensor<T>,
-  inputC: Tensor<T>,
-  params: Tensor<T>,
-  rnnMode: RnnMode = .lstm,
-  inputMode: InputMode = .linearInput,
-  direction: Direction = .unidirectional,
-  dropout: Double = 0,
-  seed: Int64 = 0,
-  seed2: Int64 = 0,
-  isTraining: Bool = true
-) -> (output: Tensor<T>, outputH: Tensor<T>, outputC: Tensor<T>, reserveSpace: Tensor<T>, hostReserved: Tensor<Int8>) {
-  let op = TFE_Op("CudnnRNNV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("rnn_mode", rnnMode.cName)
-  op.setAttr("input_mode", inputMode.cName)
-  op.setAttr("direction", direction.cName)
-  op.setAttr("dropout", dropout)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("is_training", isTraining)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputH)
-  let _ = op.addInput(inputC)
-  let _ = op.addInput(params)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// A RNN backed by cuDNN.
-///
-/// Computes the RNN from the input and initial states, with respect to the params
-/// buffer. Accepts one extra input "sequence_lengths" than CudnnRNN.
-///
-/// rnn_mode: Indicates the type of the RNN model.
-/// input_mode: Indicates whether there is a linear projection between the input and
-///   the actual computation before the first layer. 'skip_input' is only allowed
-///   when input_size == num_units; 'auto_select' implies 'skip_input' when
-///   input_size == num_units; otherwise, it implies 'linear_input'.
-/// direction: Indicates whether a bidirectional model will be used. Should be
-///   "unidirectional" or "bidirectional".
-/// dropout: Dropout probability. When set to 0., dropout is disabled.
-/// seed: The 1st part of a seed to initialize dropout.
-/// seed2: The 2nd part of a seed to initialize dropout.
-/// input: If time_major is true, this is a 3-D tensor with the shape of
-///     [seq_length, batch_size, input_size]. If time_major is false, the shape is
-///     [batch_size, seq_length, input_size].
-/// input_h: If time_major is true, this is a 3-D tensor with the shape of
-///     [num_layer * dir, batch_size, num_units]. If time_major is false, the shape
-///     is [batch_size, num_layer * dir, num_units].
-/// input_c: For LSTM, a 3-D tensor with the shape of
-///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
-/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
-///     The size must be created through CudnnRNNParamsSize, and initialized
-///     separately. Note that they might not be compatible across different
-///     generations. So it is a good idea to save and restore
-/// sequence_lengths: a vector of lengths of each input sequence.
-/// output: If time_major is true, this is a 3-D tensor with the shape of
-///     [seq_length, batch_size, dir * num_units]. If time_major is false, the
-///     shape is [batch_size, seq_length, dir * num_units].
-/// output_h: The same shape has input_h.
-/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
-/// is_training: Indicates whether this operation is used for inferenece or
-///   training.
-/// time_major: Indicates whether the input/output format is time major or batch
-///     major.
-/// reserve_space: An opaque tensor that can be used in backprop calculation. It
-///   is only produced if is_training is true.
-@inlinable
-public static func cudnnRNNV3<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  inputH: Tensor<T>,
-  inputC: Tensor<T>,
-  params: Tensor<T>,
-  sequenceLengths: Tensor<Int32>,
-  rnnMode: RnnMode = .lstm,
-  inputMode: InputMode = .linearInput,
-  direction: Direction = .unidirectional,
-  dropout: Double = 0,
-  seed: Int64 = 0,
-  seed2: Int64 = 0,
-  isTraining: Bool = true,
-  timeMajor: Bool = true
-) -> (output: Tensor<T>, outputH: Tensor<T>, outputC: Tensor<T>, reserveSpace: Tensor<T>, hostReserved: Tensor<Int8>) {
-  let op = TFE_Op("CudnnRNNV3")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("rnn_mode", rnnMode.cName)
-  op.setAttr("input_mode", inputMode.cName)
-  op.setAttr("direction", direction.cName)
-  op.setAttr("dropout", dropout)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("is_training", isTraining)
-  op.setAttr("time_major", timeMajor)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputH)
-  let _ = op.addInput(inputC)
-  let _ = op.addInput(params)
-  let _ = op.addInput(sequenceLengths)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Compute the cumulative product of the tensor `x` along `axis`.
-///
-/// By default, this op performs an inclusive cumprod, which means that the first
-/// element of the input is identical to the first element of the output:
-///
-/// ```python
-/// tf.cumprod([a, b, c])  # => [a, a * b, a * b * c]
-/// ```
-///
-/// By setting the `exclusive` kwarg to `True`, an exclusive cumprod is
-/// performed instead:
-///
-/// ```python
-/// tf.cumprod([a, b, c], exclusive=True)  # => [1, a, a * b]
-/// ```
-///
-/// By setting the `reverse` kwarg to `True`, the cumprod is performed in the
-/// opposite direction:
-///
-/// ```python
-/// tf.cumprod([a, b, c], reverse=True)  # => [a * b * c, b * c, c]
-/// ```
-///
-/// This is more efficient than using separate `tf.reverse` ops.
-///
-/// The `reverse` and `exclusive` kwargs can also be combined:
-///
-/// ```python
-/// tf.cumprod([a, b, c], exclusive=True, reverse=True)  # => [b * c, c, 1]
-/// ```
-///
-/// - Parameters:
-///   - x: A `Tensor`. Must be one of the following types: `float32`, `float64`,
-///     `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,
-///     `complex128`, `qint8`, `quint8`, `qint32`, `half`.
-///   - axis: A `Tensor` of type `int32` (default: 0). Must be in the range
-///     `[-rank(x), rank(x))`.
-///
-/// - Attrs:
-///   - exclusive: If `True`, perform exclusive cumprod.
-///   - reverse: A `bool` (default: False).
-@inlinable
-public static func cumprod<
-    T: Numeric & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  _ x: Tensor<T>,
-  axis: Tensor<Tidx>,
-  exclusive: Bool = false,
-  reverse: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("Cumprod")
-  op.setAttr("exclusive", exclusive)
-  op.setAttr("reverse", reverse)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(axis)
-  return op.execute(Int(1))
-}
-
-/// Compute the cumulative sum of the tensor `x` along `axis`.
-///
-/// By default, this op performs an inclusive cumsum, which means that the first
-/// element of the input is identical to the first element of the output:
-///
-/// ```python
-/// tf.cumsum([a, b, c])  # => [a, a + b, a + b + c]
-/// ```
-///
-/// By setting the `exclusive` kwarg to `True`, an exclusive cumsum is
-/// performed instead:
-///
-/// ```python
-/// tf.cumsum([a, b, c], exclusive=True)  # => [0, a, a + b]
-/// ```
-///
-/// By setting the `reverse` kwarg to `True`, the cumsum is performed in the
-/// opposite direction:
-///
-/// ```python
-/// tf.cumsum([a, b, c], reverse=True)  # => [a + b + c, b + c, c]
-/// ```
-///
-/// This is more efficient than using separate `tf.reverse` ops.
-///
-/// The `reverse` and `exclusive` kwargs can also be combined:
-///
-/// ```python
-/// tf.cumsum([a, b, c], exclusive=True, reverse=True)  # => [b + c, c, 0]
-/// ```
-///
-/// - Parameters:
-///   - x: A `Tensor`. Must be one of the following types: `float32`, `float64`,
-///     `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,
-///     `complex128`, `qint8`, `quint8`, `qint32`, `half`.
-///   - axis: A `Tensor` of type `int32` (default: 0). Must be in the range
-///     `[-rank(x), rank(x))`.
-///
-/// - Attrs:
-///   - exclusive: If `True`, perform exclusive cumsum.
-///   - reverse: A `bool` (default: False).
-@inlinable
-public static func cumsum<
-    T: Numeric & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  _ x: Tensor<T>,
-  axis: Tensor<Tidx>,
-  exclusive: Bool = false,
-  reverse: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("Cumsum")
-  op.setAttr("exclusive", exclusive)
-  op.setAttr("reverse", reverse)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(axis)
-  return op.execute(Int(1))
-}
-
-/// Returns the dimension index in the destination data format given the one in
-///
-/// the source data format.
-///
-/// - Parameter x: A Tensor with each element as a dimension index in source data format.
-///   Must be in the range [-4, 4).
-///
-/// - Attrs:
-///   - src_format: source data format.
-///   - dst_format: destination data format.
-///
-/// - Output y: A Tensor with each element as a dimension index in destination data format.
-@inlinable
-public static func dataFormatDimMap<T: BinaryInteger & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  srcFormat: String = "NHWC",
-  dstFormat: String = "NCHW"
-) -> Tensor<T> {
-  let op = TFE_Op("DataFormatDimMap")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("src_format", srcFormat)
-  op.setAttr("dst_format", dstFormat)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns the permuted vector/tensor in the destination data format given the
-///
-/// one in the source data format.
-///
-/// - Parameter x: Vector of size 4 or Tensor of shape (4, 2) in source data format.
-///
-/// - Attrs:
-///   - src_format: source data format.
-///   - dst_format: destination data format.
-///
-/// - Output y: Vector of size 4 or Tensor of shape (4, 2) in destination data format.
-@inlinable
-public static func dataFormatVecPermute<T: BinaryInteger & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  srcFormat: String = "NHWC",
-  dstFormat: String = "NCHW"
-) -> Tensor<T> {
-  let op = TFE_Op("DataFormatVecPermute")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("src_format", srcFormat)
-  op.setAttr("dst_format", dstFormat)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns a serialized GraphDef representing `input_dataset`.
-///
-/// Returns a graph representation for `input_dataset`.
-///
-/// - Parameter input_dataset: A variant tensor representing the dataset to return the graph representation for.
-///
-/// - Output graph: The graph representation of the dataset (as serialized GraphDef).
-@inlinable
-public static func datasetToGraph(
-  inputDataset: VariantHandle
-) -> StringTensor {
-  let op = TFE_Op("DatasetToGraph")
-  let _ = op.addInput(inputDataset)
-  return op.execute(Int(1))
-}
-
-/// Outputs the single element from the given dataset.
-///
-/// - Parameter dataset: A handle to a dataset that contains a single element.
-///
-/// - Output components: The components of the single element of `input`.
-@inlinable
-public static func datasetToSingleElement<OutputTypes: TensorGroup>(
-  dataset: VariantHandle,
-  outputShapes: [TensorShape?]
-) -> OutputTypes {
-  let op = TFE_Op("DatasetToSingleElement")
-  op.setAttr("output_types", OutputTypes._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(dataset)
-  return op.execute(Int(OutputTypes._typeList.count))
-}
-
-/// Identity op for gradient debugging.
-///
-/// This op is hidden from public in Python. It is used by TensorFlow Debugger to
-/// register gradient tensors for gradient debugging.
-/// This op operates on non-reference-type tensors.
-@inlinable
-public static func debugGradientIdentity<T: TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("DebugGradientIdentity")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Debug Identity Op.
-///
-/// Provides an identity mapping of the non-Ref type input tensor for debugging.
-///
-/// - Parameter input: Input tensor, non-Reference type.
-///
-/// - Attrs:
-///   - tensor_name: Name of the input tensor.
-///   - debug_urls: List of URLs to debug targets, e.g.,
-///     file:///foo/tfdbg_dump, grpc:://localhost:11011
-///   - gated_grpc: Whether this op will be gated. If any of the debug_urls of this
-///     debug node is of the grpc:// scheme, when the value of this attribute is set
-///     to True, the data will not actually be sent via the grpc stream unless this
-///     debug op has been enabled at the debug_url. If all of the debug_urls of this
-///     debug node are of the grpc:// scheme and the debug op is enabled at none of
-///     them, the output will be an empty Tensor.
-///
-/// - Output output: Output tensor that equals the input tensor.
-@inlinable
-public static func debugIdentity<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  deviceName: String,
-  tensorName: String,
-  debugUrls: [String],
-  gatedGrpc: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("DebugIdentity")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("device_name", deviceName)
-  op.setAttr("tensor_name", tensorName)
-  op.setAttr("debug_urls", debugUrls)
-  op.setAttr("gated_grpc", gatedGrpc)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Debug NaN Value Counter Op
-///
-/// Counts number of NaNs in the input tensor, for debugging.
-///
-/// - Parameter input: Input tensor, non-Reference type.
-///
-/// - Attrs:
-///   - tensor_name: Name of the input tensor.
-///   - debug_urls: List of URLs to debug targets, e.g.,
-///     file:///foo/tfdbg_dump, grpc:://localhost:11011.
-///   - gated_grpc: Whether this op will be gated. If any of the debug_urls of this
-///     debug node is of the grpc:// scheme, when the value of this attribute is set
-///     to True, the data will not actually be sent via the grpc stream unless this
-///     debug op has been enabled at the debug_url. If all of the debug_urls of this
-///     debug node are of the grpc:// scheme and the debug op is enabled at none of
-///     them, the output will be an empty Tensor.
-///
-/// - Output output: An integer output tensor that is the number of NaNs in the input.
-@inlinable
-public static func debugNanCount<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  deviceName: String,
-  tensorName: String,
-  debugUrls: [String],
-  gatedGrpc: Bool = false
-) -> Tensor<Int64> {
-  let op = TFE_Op("DebugNanCount")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("device_name", deviceName)
-  op.setAttr("tensor_name", tensorName)
-  op.setAttr("debug_urls", debugUrls)
-  op.setAttr("gated_grpc", gatedGrpc)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Debug Numeric Summary Op.
-///
-/// Provide a basic summary of numeric value types, range and distribution.
-///
-/// - Parameter input: Input tensor, non-Reference type, float or double.
-///
-/// - Attrs:
-///   - tensor_name: Name of the input tensor.
-///   - debug_urls: List of URLs to debug targets, e.g.,
-///     file:///foo/tfdbg_dump, grpc:://localhost:11011
-///   - lower_bound: (float) The lower bound <= which values will be included in the
-///     generalized -inf count. Default: -inf.
-///   - upper_bound: (float) The upper bound >= which values will be included in the
-///     generalized +inf count. Default: +inf.
-///   - mute_if_healthy: (bool) Do not send data to the debug URLs unless at least one
-///     of elements [2], [3] and [7] (i.e., the nan count and the generalized -inf and
-///     inf counts) is non-zero.
-///   - gated_grpc: Whether this op will be gated. If any of the debug_urls of this
-///     debug node is of the grpc:// scheme, when the value of this attribute is set
-///     to True, the data will not actually be sent via the grpc stream unless this
-///     debug op has been enabled at the debug_url. If all of the debug_urls of this
-///     debug node are of the grpc:// scheme and the debug op is enabled at none of
-///     them, the output will be an empty Tensor.
-///
-/// - Output output: A double tensor of shape [14 + nDimensions], where nDimensions is the
-///     the number of dimensions of the tensor's shape. The elements of output are:
-///     [0]: is initialized (1.0) or not (0.0).
-///     [1]: total number of elements
-///     [2]: NaN element count
-///     [3]: generalized -inf count: elements <= lower_bound. lower_bound is -inf by
-///       default.
-///     [4]: negative element count (excluding -inf), if lower_bound is the default
-///       -inf. Otherwise, this is the count of elements > lower_bound and < 0.
-///     [5]: zero element count
-///     [6]: positive element count (excluding +inf), if upper_bound is the default
-///       -inf. Otherwise, this is the count of elements < upper_bound and > 0.
-///     [7]: generalized +inf count, elements >= upper_bound. upper_bound is +inf by
-///       default.
-///   Output elements [1:8] are all zero, if the tensor is uninitialized.
-///     [8]: minimum of all non-inf and non-NaN elements.
-///          If uninitialized or no such element exists: +inf.
-///     [9]: maximum of all non-inf and non-NaN elements.
-///          If uninitialized or no such element exists: -inf.
-///     [10]: mean of all non-inf and non-NaN elements.
-///           If uninitialized or no such element exists: NaN.
-///     [11]: variance of all non-inf and non-NaN elements.
-///           If uninitialized or no such element exists: NaN.
-///     [12]: Data type of the tensor encoded as an enum integer. See the DataType
-///           proto for more details.
-///     [13]: Number of dimensions of the tensor (ndims).
-///     [14+]: Sizes of the dimensions.
-@inlinable
-public static func debugNumericSummary<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  deviceName: String,
-  tensorName: String,
-  debugUrls: [String],
-  lowerBound: Double = -Double.infinity,
-  upperBound: Double = Double.infinity,
-  muteIfHealthy: Bool = false,
-  gatedGrpc: Bool = false
-) -> Tensor<Double> {
-  let op = TFE_Op("DebugNumericSummary")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("device_name", deviceName)
-  op.setAttr("tensor_name", tensorName)
-  op.setAttr("debug_urls", debugUrls)
-  op.setAttr("lower_bound", lowerBound)
-  op.setAttr("upper_bound", upperBound)
-  op.setAttr("mute_if_healthy", muteIfHealthy)
-  op.setAttr("gated_grpc", gatedGrpc)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Decode and Crop a JPEG-encoded image to a uint8 tensor.
-///
-/// The attr `channels` indicates the desired number of color channels for the
-/// decoded image.
-///
-/// Accepted values are:
-///
-/// *   0: Use the number of channels in the JPEG-encoded image.
-/// *   1: output a grayscale image.
-/// *   3: output an RGB image.
-///
-/// If needed, the JPEG-encoded image is transformed to match the requested number
-/// of color channels.
-///
-/// The attr `ratio` allows downscaling the image by an integer factor during
-/// decoding.  Allowed values are: 1, 2, 4, and 8.  This is much faster than
-/// downscaling the image later.
-///
-///
-/// It is equivalent to a combination of decode and crop, but much faster by only
-/// decoding partial jpeg image.
-///
-/// - Parameters:
-///   - contents: 0-D.  The JPEG-encoded image.
-///   - crop_window: 1-D.  The crop window: [crop_y, crop_x, crop_height, crop_width].
-///
-/// - Attrs:
-///   - channels: Number of color channels for the decoded image.
-///   - ratio: Downscaling ratio.
-///   - fancy_upscaling: If true use a slower but nicer upscaling of the
-///     chroma planes (yuv420/422 only).
-///   - try_recover_truncated: If true try to recover an image from truncated input.
-///   - acceptable_fraction: The minimum required fraction of lines before a truncated
-///     input is accepted.
-///   - dct_method: string specifying a hint about the algorithm used for
-///     decompression.  Defaults to "" which maps to a system-specific
-///     default.  Currently valid values are ["INTEGER_FAST",
-///     "INTEGER_ACCURATE"].  The hint may be ignored (e.g., the internal
-///     jpeg library changes to a version that does not have that specific
-///     option.)
-///
-/// - Output image: 3-D with shape `[height, width, channels]`..
-@inlinable
-public static func decodeAndCropJpeg(
-  contents: StringTensor,
-  cropWindow: Tensor<Int32>,
-  channels: Int64 = 0,
-  ratio: Int64 = 1,
-  fancyUpscaling: Bool = true,
-  tryRecoverTruncated: Bool = false,
-  acceptableFraction: Double = 1,
-  dctMethod: String
-) -> Tensor<UInt8> {
-  let op = TFE_Op("DecodeAndCropJpeg")
-  op.setAttr("channels", channels)
-  op.setAttr("ratio", ratio)
-  op.setAttr("fancy_upscaling", fancyUpscaling)
-  op.setAttr("try_recover_truncated", tryRecoverTruncated)
-  op.setAttr("acceptable_fraction", acceptableFraction)
-  op.setAttr("dct_method", dctMethod)
-  let _ = op.addInput(contents)
-  let _ = op.addInput(cropWindow)
-  return op.execute(Int(1))
-}
-
-/// Decode web-safe base64-encoded strings.
-///
-/// Input may or may not have padding at the end. See EncodeBase64 for padding.
-/// Web-safe means that input must use - and _ instead of + and /.
-///
-/// - Parameter input: Base64 strings to decode.
-///
-/// - Output output: Decoded strings.
-@inlinable
-public static func decodeBase64(
-  _ input: StringTensor
-) -> StringTensor {
-  let op = TFE_Op("DecodeBase64")
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Decode the first frame of a BMP-encoded image to a uint8 tensor.
-///
-/// The attr `channels` indicates the desired number of color channels for the
-/// decoded image.
-///
-/// Accepted values are:
-///
-/// *   0: Use the number of channels in the BMP-encoded image.
-/// *   3: output an RGB image.
-/// *   4: output an RGBA image.
-///
-/// - Parameter contents: 0-D.  The BMP-encoded image.
-///
-/// - Output image: 3-D with shape `[height, width, channels]`. RGB order
-@inlinable
-public static func decodeBmp(
-  contents: StringTensor,
-  channels: Int64 = 0
-) -> Tensor<UInt8> {
-  let op = TFE_Op("DecodeBmp")
-  op.setAttr("channels", channels)
-  let _ = op.addInput(contents)
-  return op.execute(Int(1))
-}
-
-/// Convert CSV records to tensors. Each column maps to one tensor.
-///
-/// RFC 4180 format is expected for the CSV records.
-/// (https://tools.ietf.org/html/rfc4180)
-/// Note that we allow leading and trailing spaces with int or float field.
-///
-/// - Parameters:
-///   - records: Each string is a record/row in the csv and all records should have
-///     the same format.
-///   - record_defaults: One tensor per column of the input record, with either a
-///     scalar default value for that column or an empty vector if the column is
-///     required.
-///
-/// - Attrs:
-///   - field_delim: char delimiter to separate fields in a record.
-///   - use_quote_delim: If false, treats double quotation marks as regular
-///     characters inside of the string fields (ignoring RFC 4180, Section 2,
-///     Bullet 5).
-///   - na_value: Additional string to recognize as NA/NaN.
-///
-/// - Output output: Each tensor will have the same shape as records.
-@inlinable
-public static func decodeCSV<OutType: TensorArrayProtocol>(
-  records: StringTensor,
-  recordDefaults: OutType,
-  fieldDelim: String = ",",
-  useQuoteDelim: Bool = true,
-  naValue: String,
-  selectCols: [Int32]
-) -> OutType {
-  let op = TFE_Op("DecodeCSV")
-  op.setAttr("OUT_TYPE", recordDefaults._typeList)
-  op.setAttr("field_delim", fieldDelim)
-  op.setAttr("use_quote_delim", useQuoteDelim)
-  op.setAttr("na_value", naValue)
-  op.setAttr("select_cols", selectCols)
-  let _ = op.addInput(records)
-  let _ = op.addInputList(recordDefaults)
-  return op.execute(Int(recordDefaults._typeList.count))
-}
-
-/// Decompress strings.
-///
-/// This op decompresses each element of the `bytes` input `Tensor`, which
-/// is assumed to be compressed using the given `compression_type`.
-///
-/// The `output` is a string `Tensor` of the same shape as `bytes`,
-/// each element containing the decompressed data from the corresponding
-/// element in `bytes`.
-///
-/// - Parameter bytes: A Tensor of string which is compressed.
-///
-/// - Attr compression_type: A scalar containing either (i) the empty string (no
-///   compression), (ii) "ZLIB", or (iii) "GZIP".
-///
-/// - Output output: A Tensor with the same shape as input `bytes`, uncompressed
-///   from bytes.
-@inlinable
-public static func decodeCompressed(
-  bytes: StringTensor,
-  compressionType: String
-) -> StringTensor {
-  let op = TFE_Op("DecodeCompressed")
-  op.setAttr("compression_type", compressionType)
-  let _ = op.addInput(bytes)
-  return op.execute(Int(1))
-}
-
-/// Decode the frame(s) of a GIF-encoded image to a uint8 tensor.
-///
-/// GIF images with frame or transparency compression are not supported.
-/// On Linux and MacOS systems, convert animated GIFs from compressed to
-/// uncompressed by running:
-///
-///     convert $src.gif -coalesce $dst.gif
-///
-/// This op also supports decoding JPEGs and PNGs, though it is cleaner to use
-/// `tf.image.decode_image`.
-///
-/// - Parameter contents: 0-D.  The GIF-encoded image.
-///
-/// - Output image: 4-D with shape `[num_frames, height, width, 3]`. RGB channel order.
-@inlinable
-public static func decodeGif(
-  contents: StringTensor
-) -> Tensor<UInt8> {
-  let op = TFE_Op("DecodeGif")
-  let _ = op.addInput(contents)
-  return op.execute(Int(1))
-}
-
-/// Convert JSON-encoded Example records to binary protocol buffer strings.
-///
-/// This op translates a tensor containing Example records, encoded using
-/// the [standard JSON
-/// mapping](https://developers.google.com/protocol-buffers/docs/proto3#json),
-/// into a tensor containing the same records encoded as binary protocol
-/// buffers. The resulting tensor can then be fed to any of the other
-/// Example-parsing ops.
-///
-/// - Parameter json_examples: Each string is a JSON object serialized according to the JSON
-///   mapping of the Example proto.
-///
-/// - Output binary_examples: Each string is a binary Example protocol buffer corresponding
-///   to the respective element of `json_examples`.
-@inlinable
-public static func decodeJSONExample(
-  jsonExamples: StringTensor
-) -> StringTensor {
-  let op = TFE_Op("DecodeJSONExample")
-  let _ = op.addInput(jsonExamples)
-  return op.execute(Int(1))
-}
-
-/// Decode a JPEG-encoded image to a uint8 tensor.
-///
-/// The attr `channels` indicates the desired number of color channels for the
-/// decoded image.
-///
-/// Accepted values are:
-///
-/// *   0: Use the number of channels in the JPEG-encoded image.
-/// *   1: output a grayscale image.
-/// *   3: output an RGB image.
-///
-/// If needed, the JPEG-encoded image is transformed to match the requested number
-/// of color channels.
-///
-/// The attr `ratio` allows downscaling the image by an integer factor during
-/// decoding.  Allowed values are: 1, 2, 4, and 8.  This is much faster than
-/// downscaling the image later.
-///
-///
-/// This op also supports decoding PNGs and non-animated GIFs since the interface is
-/// the same, though it is cleaner to use `tf.image.decode_image`.
-///
-/// - Parameter contents: 0-D.  The JPEG-encoded image.
-///
-/// - Attrs:
-///   - channels: Number of color channels for the decoded image.
-///   - ratio: Downscaling ratio.
-///   - fancy_upscaling: If true use a slower but nicer upscaling of the
-///     chroma planes (yuv420/422 only).
-///   - try_recover_truncated: If true try to recover an image from truncated input.
-///   - acceptable_fraction: The minimum required fraction of lines before a truncated
-///     input is accepted.
-///   - dct_method: string specifying a hint about the algorithm used for
-///     decompression.  Defaults to "" which maps to a system-specific
-///     default.  Currently valid values are ["INTEGER_FAST",
-///     "INTEGER_ACCURATE"].  The hint may be ignored (e.g., the internal
-///     jpeg library changes to a version that does not have that specific
-///     option.)
-///
-/// - Output image: 3-D with shape `[height, width, channels]`..
-@inlinable
-public static func decodeJpeg(
-  contents: StringTensor,
-  channels: Int64 = 0,
-  ratio: Int64 = 1,
-  fancyUpscaling: Bool = true,
-  tryRecoverTruncated: Bool = false,
-  acceptableFraction: Double = 1,
-  dctMethod: String
-) -> Tensor<UInt8> {
-  let op = TFE_Op("DecodeJpeg")
-  op.setAttr("channels", channels)
-  op.setAttr("ratio", ratio)
-  op.setAttr("fancy_upscaling", fancyUpscaling)
-  op.setAttr("try_recover_truncated", tryRecoverTruncated)
-  op.setAttr("acceptable_fraction", acceptableFraction)
-  op.setAttr("dct_method", dctMethod)
-  let _ = op.addInput(contents)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func decodePaddedRaw<OutType: Numeric & TensorFlowScalar>(
-  inputBytes: StringTensor,
-  fixedLength: Tensor<Int32>,
-  littleEndian: Bool = true
-) -> Tensor<OutType> {
-  let op = TFE_Op("DecodePaddedRaw")
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("little_endian", littleEndian)
-  let _ = op.addInput(inputBytes)
-  let _ = op.addInput(fixedLength)
-  return op.execute(Int(1))
-}
-
-/// Decode a PNG-encoded image to a uint8 or uint16 tensor.
-///
-/// The attr `channels` indicates the desired number of color channels for the
-/// decoded image.
-///
-/// Accepted values are:
-///
-/// *   0: Use the number of channels in the PNG-encoded image.
-/// *   1: output a grayscale image.
-/// *   3: output an RGB image.
-/// *   4: output an RGBA image.
-///
-/// If needed, the PNG-encoded image is transformed to match the requested number
-/// of color channels.
-///
-/// This op also supports decoding JPEGs and non-animated GIFs since the interface
-/// is the same, though it is cleaner to use `tf.image.decode_image`.
-///
-/// - Parameter contents: 0-D.  The PNG-encoded image.
-///
-/// - Attr channels: Number of color channels for the decoded image.
-///
-/// - Output image: 3-D with shape `[height, width, channels]`.
-@inlinable
-public static func decodePng<Dtype: UnsignedInteger & TensorFlowScalar>(
-  contents: StringTensor,
-  channels: Int64 = 0
-) -> Tensor<Dtype> {
-  let op = TFE_Op("DecodePng")
-  op.setAttr("channels", channels)
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(contents)
-  return op.execute(Int(1))
-}
-
-/// The op extracts fields from a serialized protocol buffers message into tensors.
-///
-/// The `decode_proto` op extracts fields from a serialized protocol buffers
-/// message into tensors.  The fields in `field_names` are decoded and converted
-/// to the corresponding `output_types` if possible.
-///
-/// A `message_type` name must be provided to give context for the field
-/// names. The actual message descriptor can be looked up either in the
-/// linked-in descriptor pool or a filename provided by the caller using
-/// the `descriptor_source` attribute.
-///
-/// Each output tensor is a dense tensor. This means that it is padded to
-/// hold the largest number of repeated elements seen in the input
-/// minibatch. (The shape is also padded by one to prevent zero-sized
-/// dimensions). The actual repeat counts for each example in the
-/// minibatch can be found in the `sizes` output. In many cases the output
-/// of `decode_proto` is fed immediately into tf.squeeze if missing values
-/// are not a concern. When using tf.squeeze, always pass the squeeze
-/// dimension explicitly to avoid surprises.
-///
-/// For the most part, the mapping between Proto field types and
-/// TensorFlow dtypes is straightforward. However, there are a few
-/// special cases:
-///
-/// - A proto field that contains a submessage or group can only be converted
-/// to `DT_STRING` (the serialized submessage). This is to reduce the
-/// complexity of the API. The resulting string can be used as input
-/// to another instance of the decode_proto op.
-///
-/// - TensorFlow lacks support for unsigned integers. The ops represent uint64
-/// types as a `DT_INT64` with the same twos-complement bit pattern
-/// (the obvious way). Unsigned int32 values can be represented exactly by
-/// specifying type `DT_INT64`, or using twos-complement if the caller
-/// specifies `DT_INT32` in the `output_types` attribute.
-///
-/// The `descriptor_source` attribute selects a source of protocol
-/// descriptors to consult when looking up `message_type`. This may be a
-/// filename containing a serialized `FileDescriptorSet` message,
-/// or the special value `local://`, in which case only descriptors linked
-/// into the code will be searched; the filename can be on any filesystem
-/// accessible to TensorFlow.
-///
-/// You can build a `descriptor_source` file using the `--descriptor_set_out`
-/// and `--include_imports` options to the protocol compiler `protoc`.
-///
-/// The `local://` database only covers descriptors linked into the
-/// code via C++ libraries, not Python imports. You can link in a proto descriptor
-/// by creating a cc_library target with alwayslink=1.
-///
-/// Both binary and text proto serializations are supported, and can be
-/// chosen using the `format` attribute.
-///
-/// - Parameter bytes: Tensor of serialized protos with shape `batch_shape`.
-///
-/// - Attrs:
-///   - message_type: Name of the proto message type to decode.
-///   - field_names: List of strings containing proto field names. An extension field can be decoded
-///     by using its full name, e.g. EXT_PACKAGE.EXT_FIELD_NAME.
-///   - output_types: List of TF types to use for the respective field in field_names.
-///   - descriptor_source: Either the special value `local://` or a path to a file containing
-///     a serialized `FileDescriptorSet`.
-///   - message_format: Either `binary` or `text`.
-///   - sanitize: Whether to sanitize the result or not.
-///
-/// - Outputs:
-///   - sizes: Tensor of int32 with shape `[batch_shape, len(field_names)]`.
-///     Each entry is the number of values found for the corresponding field.
-///     Optional fields may have 0 or 1 values.
-///   - values: List of tensors containing values for the corresponding field.
-///     `values[i]` has datatype `output_types[i]`
-///     and shape `[batch_shape, max(sizes[...,i])]`.
-@inlinable
-public static func decodeProtoV2<OutputTypes: TensorGroup>(
-  bytes: StringTensor,
-  messageType: String,
-  fieldNames: [String],
-  descriptorSource: String = "local://",
-  messageFormat: String = "binary",
-  sanitize: Bool = false
-) -> (sizes: Tensor<Int32>, values: OutputTypes) {
-  let op = TFE_Op("DecodeProtoV2")
-  op.setAttr("message_type", messageType)
-  op.setAttr("field_names", fieldNames)
-  op.setAttr("output_types", OutputTypes._typeList)
-  op.setAttr("descriptor_source", descriptorSource)
-  op.setAttr("message_format", messageFormat)
-  op.setAttr("sanitize", sanitize)
-  let _ = op.addInput(bytes)
-  return op.execute(Int(1), Int(OutputTypes._typeList.count))
-}
-
-/// Reinterpret the bytes of a string as a vector of numbers.
-///
-/// - Parameter bytes: All the elements must have the same length.
-///
-/// - Attr little_endian: Whether the input `bytes` are in little-endian order.
-///   Ignored for `out_type` values that are stored in a single byte like
-///   `uint8`.
-///
-/// - Output output: A Tensor with one more dimension than the input `bytes`.  The
-///   added dimension will have size equal to the length of the elements
-///   of `bytes` divided by the number of bytes to represent `out_type`.
-@inlinable
-public static func decodeRaw<OutType: TensorFlowScalar>(
-  bytes: StringTensor,
-  littleEndian: Bool = true
-) -> Tensor<OutType> {
-  let op = TFE_Op("DecodeRaw")
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("little_endian", littleEndian)
-  let _ = op.addInput(bytes)
-  return op.execute(Int(1))
-}
-
-/// Decode a 16-bit PCM WAV file to a float tensor.
-///
-/// The -32768 to 32767 signed 16-bit values will be scaled to -1.0 to 1.0 in float.
-///
-/// When desired_channels is set, if the input contains fewer channels than this
-/// then the last channel will be duplicated to give the requested number, else if
-/// the input has more channels than requested then the additional channels will be
-/// ignored.
-///
-/// If desired_samples is set, then the audio will be cropped or padded with zeroes
-/// to the requested length.
-///
-/// The first output contains a Tensor with the content of the audio samples. The
-/// lowest dimension will be the number of channels, and the second will be the
-/// number of samples. For example, a ten-sample-long stereo WAV file should give an
-/// output shape of [10, 2].
-///
-/// - Parameter contents: The WAV-encoded audio, usually from a file.
-///
-/// - Attrs:
-///   - desired_channels: Number of sample channels wanted.
-///   - desired_samples: Length of audio requested.
-///
-/// - Outputs:
-///   - audio: 2-D with shape `[length, channels]`.
-///   - sample_rate: Scalar holding the sample rate found in the WAV header.
-@inlinable
-public static func decodeWav(
-  contents: StringTensor,
-  desiredChannels: Int64 = -1,
-  desiredSamples: Int64 = -1
-) -> (audio: Tensor<Float>, sampleRate: Tensor<Int32>) {
-  let op = TFE_Op("DecodeWav")
-  op.setAttr("desired_channels", desiredChannels)
-  op.setAttr("desired_samples", desiredSamples)
-  let _ = op.addInput(contents)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Makes a copy of `x`.
-///
-/// - Parameter x: The source tensor of type `T`.
-///
-/// - Output y:     y: A `Tensor` of type `T`. A copy of `x`. Guaranteed that `y`
-///         is not an alias of `x`.
-@inlinable
-public static func deepCopy<T: TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("DeepCopy")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// A container for an iterator resource.
-///
-/// - Parameters:
-///   - handle: A handle to the iterator to delete.
-///   - deleter: A variant deleter.
-@inlinable
-public static func deleteIterator(
-  handle: ResourceHandle,
-  deleter: VariantHandle
-) {
-  let op = TFE_Op("DeleteIterator")
-  let _ = op.addInput(handle)
-  let _ = op.addInput(deleter)
-  op.execute()
-}
-
-/// Delete the tensor specified by its handle in the session.
-///
-/// - Parameter handle: The handle for a tensor stored in the session state.
-@inlinable
-public static func deleteSessionTensor(
-  handle: StringTensor
-) {
-  let op = TFE_Op("DeleteSessionTensor")
-  let _ = op.addInput(handle)
-  op.execute()
-}
-
-/// Applies set operation along last dimension of 2 `Tensor` inputs.
-///
-/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
-///
-/// Output `result` is a `SparseTensor` represented by `result_indices`,
-/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
-/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
-/// dimension contains the result of `set_operation` applied to the corresponding
-/// `[0...n-1]` dimension of `set`.
-///
-/// - Parameters:
-///   - set1: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
-///     Dimension `n` contains values in a set, duplicates are allowed but ignored.
-///   - set2: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set1`.
-///     Dimension `n` contains values in a set, duplicates are allowed but ignored.
-///
-/// - Outputs:
-///   - result_indices: 2D indices of a `SparseTensor`.
-///   - result_values: 1D values of a `SparseTensor`.
-///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
-///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
-///     is the max result set size across all `0...n-1` dimensions.
-@inlinable
-public static func denseToDenseSetOperation<T: BinaryInteger & TensorFlowScalar>(
-  set1: Tensor<T>,
-  set2: Tensor<T>,
-  setOperation: String,
-  validateIndices: Bool = true
-) -> (resultIndices: Tensor<Int64>, resultValues: Tensor<T>, resultShape: Tensor<Int64>) {
-  let op = TFE_Op("DenseToDenseSetOperation")
-  op.setAttr("set_operation", setOperation)
-  op.setAttr("validate_indices", validateIndices)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(set1)
-  let _ = op.addInput(set2)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Applies set operation along last dimension of 2 `Tensor` inputs.
-///
-/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
-///
-/// Output `result` is a `SparseTensor` represented by `result_indices`,
-/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
-/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
-/// dimension contains the result of `set_operation` applied to the corresponding
-/// `[0...n-1]` dimension of `set`.
-///
-/// - Parameters:
-///   - set1: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
-///     Dimension `n` contains values in a set, duplicates are allowed but ignored.
-///   - set2: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set1`.
-///     Dimension `n` contains values in a set, duplicates are allowed but ignored.
-///
-/// - Outputs:
-///   - result_indices: 2D indices of a `SparseTensor`.
-///   - result_values: 1D values of a `SparseTensor`.
-///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
-///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
-///     is the max result set size across all `0...n-1` dimensions.
-@inlinable
-public static func denseToDenseSetOperation(
-  set1: StringTensor,
-  set2: StringTensor,
-  setOperation: String,
-  validateIndices: Bool = true
-) -> (resultIndices: Tensor<Int64>, resultValues: StringTensor, resultShape: Tensor<Int64>) {
-  let op = TFE_Op("DenseToDenseSetOperation")
-  op.setAttr("set_operation", setOperation)
-  op.setAttr("validate_indices", validateIndices)
-  op.setAttr("T", TensorDataType(TF_STRING))
-  let _ = op.addInput(set1)
-  let _ = op.addInput(set2)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Applies set operation along last dimension of `Tensor` and `SparseTensor`.
-///
-/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
-///
-/// Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
-/// and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
-/// as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
-/// ignored.
-///
-/// If `validate_indices` is `True`, this op validates the order and range of `set2`
-/// indices.
-///
-/// Output `result` is a `SparseTensor` represented by `result_indices`,
-/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
-/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
-/// dimension contains the result of `set_operation` applied to the corresponding
-/// `[0...n-1]` dimension of `set`.
-///
-/// - Parameters:
-///   - set1: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
-///     Dimension `n` contains values in a set, duplicates are allowed but ignored.
-///   - set2_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
-///     order.
-///   - set2_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
-///     order.
-///   - set2_shape: 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
-///     be the same as the 1st `n-1` dimensions of `set1`, `result_shape[n]` is the
-///     max set size across `n-1` dimensions.
-///
-/// - Outputs:
-///   - result_indices: 2D indices of a `SparseTensor`.
-///   - result_values: 1D values of a `SparseTensor`.
-///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
-///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
-///     is the max result set size across all `0...n-1` dimensions.
-@inlinable
-public static func denseToSparseSetOperation<T: BinaryInteger & TensorFlowScalar>(
-  set1: Tensor<T>,
-  set2Indices: Tensor<Int64>,
-  set2Values: Tensor<T>,
-  set2Shape: Tensor<Int64>,
-  setOperation: String,
-  validateIndices: Bool = true
-) -> (resultIndices: Tensor<Int64>, resultValues: Tensor<T>, resultShape: Tensor<Int64>) {
-  let op = TFE_Op("DenseToSparseSetOperation")
-  op.setAttr("set_operation", setOperation)
-  op.setAttr("validate_indices", validateIndices)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(set1)
-  let _ = op.addInput(set2Indices)
-  let _ = op.addInput(set2Values)
-  let _ = op.addInput(set2Shape)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Applies set operation along last dimension of `Tensor` and `SparseTensor`.
-///
-/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
-///
-/// Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
-/// and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
-/// as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
-/// ignored.
-///
-/// If `validate_indices` is `True`, this op validates the order and range of `set2`
-/// indices.
-///
-/// Output `result` is a `SparseTensor` represented by `result_indices`,
-/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
-/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
-/// dimension contains the result of `set_operation` applied to the corresponding
-/// `[0...n-1]` dimension of `set`.
-///
-/// - Parameters:
-///   - set1: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
-///     Dimension `n` contains values in a set, duplicates are allowed but ignored.
-///   - set2_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
-///     order.
-///   - set2_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
-///     order.
-///   - set2_shape: 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
-///     be the same as the 1st `n-1` dimensions of `set1`, `result_shape[n]` is the
-///     max set size across `n-1` dimensions.
-///
-/// - Outputs:
-///   - result_indices: 2D indices of a `SparseTensor`.
-///   - result_values: 1D values of a `SparseTensor`.
-///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
-///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
-///     is the max result set size across all `0...n-1` dimensions.
-@inlinable
-public static func denseToSparseSetOperation(
-  set1: StringTensor,
-  set2Indices: Tensor<Int64>,
-  set2Values: StringTensor,
-  set2Shape: Tensor<Int64>,
-  setOperation: String,
-  validateIndices: Bool = true
-) -> (resultIndices: Tensor<Int64>, resultValues: StringTensor, resultShape: Tensor<Int64>) {
-  let op = TFE_Op("DenseToSparseSetOperation")
-  op.setAttr("set_operation", setOperation)
-  op.setAttr("validate_indices", validateIndices)
-  op.setAttr("T", TensorDataType(TF_STRING))
-  let _ = op.addInput(set1)
-  let _ = op.addInput(set2Indices)
-  let _ = op.addInput(set2Values)
-  let _ = op.addInput(set2Shape)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// DepthToSpace for tensors of type T.
-///
-/// Rearranges data from depth into blocks of spatial data.
-/// This is the reverse transformation of SpaceToDepth. More specifically,
-/// this op outputs a copy of the input tensor where values from the `depth`
-/// dimension are moved in spatial blocks to the `height` and `width` dimensions.
-/// The attr `block_size` indicates the input block size and how the data is moved.
-///
-///   * Chunks of data of size `block_size * block_size` from depth are rearranged
-///     into non-overlapping blocks of size `block_size x block_size`
-///   * The width the output tensor is `input_depth * block_size`, whereas the
-///     height is `input_height * block_size`.
-///   * The Y, X coordinates within each block of the output image are determined
-///     by the high order component of the input channel index.
-///   * The depth of the input tensor must be divisible by
-///     `block_size * block_size`.
-///
-/// The `data_format` attr specifies the layout of the input and output tensors
-/// with the following options:
-///   "NHWC": `[ batch, height, width, channels ]`
-///   "NCHW": `[ batch, channels, height, width ]`
-///   "NCHW_VECT_C":
-///       `qint8 [ batch, channels / 4, height, width, 4 ]`
-///
-/// It is useful to consider the operation as transforming a 6-D Tensor.
-/// e.g. for data_format = NHWC,
-///      Each element in the input tensor can be specified via 6 coordinates,
-///      ordered by decreasing memory layout significance as:
-///      n,iY,iX,bY,bX,oC  (where n=batch index, iX, iY means X or Y coordinates
-///                         within the input image, bX, bY means coordinates
-///                         within the output block, oC means output channels).
-///      The output would be the input transposed to the following layout:
-///      n,iY,bY,iX,bX,oC
-///
-/// This operation is useful for resizing the activations between convolutions
-/// (but keeping all data), e.g. instead of pooling. It is also useful for training
-/// purely convolutional models.
-///
-/// For example, given an input of shape `[1, 1, 1, 4]`, data_format = "NHWC" and
-/// block_size = 2:
-///
-/// ```
-/// x = [[[[1, 2, 3, 4]]]]
-///
-/// ```
-///
-/// This operation will output a tensor of shape `[1, 2, 2, 1]`:
-///
-/// ```
-///    [[[[1], [2]],
-///      [[3], [4]]]]
-/// ```
-///
-/// Here, the input has a batch of 1 and each batch element has shape `[1, 1, 4]`,
-/// the corresponding output will have 2x2 elements and will have a depth of
-/// 1 channel (1 = `4 / (block_size * block_size)`).
-/// The output element shape is `[2, 2, 1]`.
-///
-/// For an input tensor with larger depth, here of shape `[1, 1, 1, 12]`, e.g.
-///
-/// ```
-/// x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
-/// ```
-///
-/// This operation, for block size of 2, will return the following tensor of shape
-/// `[1, 2, 2, 3]`
-///
-/// ```
-///    [[[[1, 2, 3], [4, 5, 6]],
-///      [[7, 8, 9], [10, 11, 12]]]]
-///
-/// ```
-///
-/// Similarly, for the following input of shape `[1 2 2 4]`, and a block size of 2:
-///
-/// ```
-/// x =  [[[[1, 2, 3, 4],
-///        [5, 6, 7, 8]],
-///       [[9, 10, 11, 12],
-///        [13, 14, 15, 16]]]]
-/// ```
-///
-/// the operator will return the following tensor of shape `[1 4 4 1]`:
-///
-/// ```
-/// x = [[[ [1],   [2],  [5],  [6]],
-///       [ [3],   [4],  [7],  [8]],
-///       [ [9],  [10], [13],  [14]],
-///       [ [11], [12], [15],  [16]]]]
-///
-/// ```
-///
-/// - Attr block_size: The size of the spatial block, same as in Space2Depth.
-@inlinable
-public static func depthToSpace<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  blockSize: Int64,
-  dataFormat: DataFormat4 = .nhwc
-) -> Tensor<T> {
-  let op = TFE_Op("DepthToSpace")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("block_size", blockSize)
-  op.setAttr("data_format", dataFormat.cName)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Computes a 2-D depthwise convolution given 4-D `input` and `filter` tensors.
-///
-/// Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
-/// and a filter / kernel tensor of shape
-/// `[filter_height, filter_width, in_channels, channel_multiplier]`, containing
-/// `in_channels` convolutional filters of depth 1, `depthwise_conv2d` applies
-/// a different filter to each input channel (expanding from 1 channel to
-/// `channel_multiplier` channels for each), then concatenates the results
-/// together. Thus, the output has `in_channels * channel_multiplier` channels.
-///
-/// ```
-/// for k in 0..in_channels-1
-///   for q in 0..channel_multiplier-1
-///     output[b, i, j, k * channel_multiplier + q] =
-///       sum_{di, dj} input[b, strides[1] * i + di, strides[2] * j + dj, k] *
-///                         filter[di, dj, k, q]
-/// ```
-///
-/// Must have `strides[0] = strides[3] = 1`.  For the most common case of the same
-/// horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
-///
-/// - Attrs:
-///   - strides: 1-D of length 4.  The stride of the sliding window for each dimension
-///     of `input`.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, height, width, channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, channels, height, width].
-///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
-///     `input`. If set to k > 1, there will be k-1 skipped cells between each filter
-///     element on that dimension. The dimension order is determined by the value of
-///     `data_format`, see above for details. Dilations in the batch and depth
-///     dimensions must be 1.
-@inlinable
-public static func depthwiseConv2dNative<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  filter: Tensor<T>,
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat = .nhwc,
-  dilations: [Int32] = [1, 1, 1, 1]
-) -> Tensor<T> {
-  let op = TFE_Op("DepthwiseConv2dNative")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradients of depthwise convolution with respect to the filter.
-///
-/// - Parameters:
-///   - input: 4-D with shape based on `data_format`.  For example, if
-///     `data_format` is 'NHWC' then `input` is a 4-D `[batch, in_height,
-///     in_width, in_channels]` tensor.
-///   - filter_sizes: An integer vector representing the tensor shape of `filter`,
-///     where `filter` is a 4-D
-///     `[filter_height, filter_width, in_channels, depthwise_multiplier]` tensor.
-///   - out_backprop: 4-D with shape  based on `data_format`.
-///     For example, if `data_format` is 'NHWC' then
-///     out_backprop shape is `[batch, out_height, out_width, out_channels]`.
-///     Gradients w.r.t. the output of the convolution.
-///
-/// - Attrs:
-///   - strides: The stride of the sliding window for each dimension of the input
-///     of the convolution.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, height, width, channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, channels, height, width].
-///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
-///     `input`. If set to k > 1, there will be k-1 skipped cells between each filter
-///     element on that dimension. The dimension order is determined by the value of
-///     `data_format`, see above for details. Dilations in the batch and depth
-///     dimensions must be 1.
-///
-/// - Output output: 4-D with shape
-///   `[filter_height, filter_width, in_channels, out_channels]`.  Gradient w.r.t.
-///   the `filter` input of the convolution.
-@inlinable
-public static func depthwiseConv2dNativeBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  filterSizes: Tensor<Int32>,
-  outBackprop: Tensor<T>,
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat = .nhwc,
-  dilations: [Int32] = [1, 1, 1, 1]
-) -> Tensor<T> {
-  let op = TFE_Op("DepthwiseConv2dNativeBackpropFilter")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filterSizes)
-  let _ = op.addInput(outBackprop)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradients of depthwise convolution with respect to the input.
-///
-/// - Parameters:
-///   - input_sizes: An integer vector representing the shape of `input`, based
-///     on `data_format`.  For example, if `data_format` is 'NHWC' then
-///      `input` is a 4-D `[batch, height, width, channels]` tensor.
-///   - filter: 4-D with shape
-///     `[filter_height, filter_width, in_channels, depthwise_multiplier]`.
-///   - out_backprop: 4-D with shape  based on `data_format`.
-///     For example, if `data_format` is 'NHWC' then
-///     out_backprop shape is `[batch, out_height, out_width, out_channels]`.
-///     Gradients w.r.t. the output of the convolution.
-///
-/// - Attrs:
-///   - strides: The stride of the sliding window for each dimension of the input
-///     of the convolution.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, height, width, channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, channels, height, width].
-///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
-///     `input`. If set to k > 1, there will be k-1 skipped cells between each filter
-///     element on that dimension. The dimension order is determined by the value of
-///     `data_format`, see above for details. Dilations in the batch and depth
-///     dimensions must be 1.
-///
-/// - Output output: 4-D with shape according to `data_format`.  For example, if
-///   `data_format` is 'NHWC', output shape is `[batch, in_height,
-///   in_width, in_channels]`.  Gradient w.r.t. the input of the
-///   convolution.
-@inlinable
-public static func depthwiseConv2dNativeBackpropInput<T: FloatingPoint & TensorFlowScalar>(
-  inputSizes: Tensor<Int32>,
-  filter: Tensor<T>,
-  outBackprop: Tensor<T>,
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat = .nhwc,
-  dilations: [Int32] = [1, 1, 1, 1]
-) -> Tensor<T> {
-  let op = TFE_Op("DepthwiseConv2dNativeBackpropInput")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(inputSizes)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(outBackprop)
-  return op.execute(Int(1))
-}
-
-/// Dequantize the 'input' tensor into a float Tensor.
-///
-/// [min_range, max_range] are scalar floats that specify the range for
-/// the 'input' data. The 'mode' attribute controls exactly which calculations are
-/// used to convert the float values to their quantized equivalents.
-///
-/// In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:
-///
-/// ```
-/// if T == qint8: in[i] += (range(T) + 1)/ 2.0
-/// out[i] = min_range + (in[i]* (max_range - min_range) / range(T))
-/// ```
-/// here `range(T) = numeric_limits<T>::max() - numeric_limits<T>::min()`
-///
-/// *MIN_COMBINED Mode Example*
-///
-/// If the input comes from a QuantizedRelu6, the output type is
-/// quint8 (range of 0-255) but the possible range of QuantizedRelu6 is
-/// 0-6.  The min_range and max_range values are therefore 0.0 and 6.0.
-/// Dequantize on quint8 will take each value, cast to float, and multiply
-/// by 6 / 255.
-/// Note that if quantizedtype is qint8, the operation will additionally add
-/// each value by 128 prior to casting.
-///
-/// If the mode is 'MIN_FIRST', then this approach is used:
-///
-/// ```c++
-/// num_discrete_values = 1 << (# of bits in T)
-/// range_adjust = num_discrete_values / (num_discrete_values - 1)
-/// range = (range_max - range_min) * range_adjust
-/// range_scale = range / num_discrete_values
-/// const double offset_input = static_cast<double>(input) - lowest_quantized;
-/// result = range_min + ((input - numeric_limits<T>::min()) * range_scale)
-/// ```
-///
-/// *SCALED mode Example*
-///
-/// `SCALED` mode matches the quantization approach used in
-/// `QuantizeAndDequantize{V2|V3}`.
-///
-/// If the mode is `SCALED`, we do not use the full range of the output type,
-/// choosing to elide the lowest possible value for symmetry (e.g., output range is
-/// -127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to
-/// 0.
-///
-/// We first find the range of values in our tensor. The
-/// range we use is always centered on 0, so we find m such that
-/// ```c++
-///   m = max(abs(input_min), abs(input_max))
-/// ```
-///
-/// Our input tensor range is then `[-m, m]`.
-///
-/// Next, we choose our fixed-point quantization buckets, `[min_fixed, max_fixed]`.
-/// If T is signed, this is
-/// ```
-///   num_bits = sizeof(T) * 8
-///   [min_fixed, max_fixed] =
-///       [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]
-/// ```
-///
-/// Otherwise, if T is unsigned, the fixed-point range is
-/// ```
-///   [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]
-/// ```
-///
-/// From this we compute our scaling factor, s:
-/// ```c++
-///   s = (2 * m) / (max_fixed - min_fixed)
-/// ```
-///
-/// Now we can dequantize the elements of our tensor:
-/// ```c++
-/// result = input * s
-/// ```
-///
-/// - Parameters:
-///   - min_range: The minimum scalar value possibly produced for the input.
-///   - max_range: The maximum scalar value possibly produced for the input.
-@inlinable
-public static func dequantize<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  minRange: Tensor<Float>,
-  maxRange: Tensor<Float>,
-  mode: Mode = .minCombined
-) -> Tensor<Float> {
-  let op = TFE_Op("Dequantize")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("mode", mode.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(minRange)
-  let _ = op.addInput(maxRange)
-  return op.execute(Int(1))
-}
-
-/// Converts the given variant tensor to an iterator and stores it in the given resource.
-///
-/// - Parameters:
-///   - resource_handle: A handle to an iterator resource.
-///   - serialized: A variant tensor storing the state of the iterator contained in the
-///     resource.
-@inlinable
-public static func deserializeIterator(
-  resourceHandle: ResourceHandle,
-  serialized: VariantHandle
-) {
-  let op = TFE_Op("DeserializeIterator")
-  let _ = op.addInput(resourceHandle)
-  let _ = op.addInput(serialized)
-  op.execute()
-}
-
-/// Deserialize and concatenate `SparseTensors` from a serialized minibatch.
-///
-/// The input `serialized_sparse` must be a string matrix of shape `[N x 3]` where
-/// `N` is the minibatch size and the rows correspond to packed outputs of
-/// `SerializeSparse`.  The ranks of the original `SparseTensor` objects
-/// must all match.  When the final `SparseTensor` is created, it has rank one
-/// higher than the ranks of the incoming `SparseTensor` objects
-/// (they have been concatenated along a new row dimension).
-///
-/// The output `SparseTensor` object's shape values for all dimensions but the
-/// first are the max across the input `SparseTensor` objects' shape values
-/// for the corresponding dimensions.  Its first shape value is `N`, the minibatch
-/// size.
-///
-/// The input `SparseTensor` objects' indices are assumed ordered in
-/// standard lexicographic order.  If this is not the case, after this
-/// step run `SparseReorder` to restore index ordering.
-///
-/// For example, if the serialized input is a `[2 x 3]` matrix representing two
-/// original `SparseTensor` objects:
-///
-///     index = [ 0]
-///             [10]
-///             [20]
-///     values = [1, 2, 3]
-///     shape = [50]
-///
-/// and
-///
-///     index = [ 2]
-///             [10]
-///     values = [4, 5]
-///     shape = [30]
-///
-/// then the final deserialized `SparseTensor` will be:
-///
-///     index = [0  0]
-///             [0 10]
-///             [0 20]
-///             [1  2]
-///             [1 10]
-///     values = [1, 2, 3, 4, 5]
-///     shape = [2 50]
-///
-/// - Parameter serialized_sparse: 2-D, The `N` serialized `SparseTensor` objects.
-///   Must have 3 columns.
-///
-/// - Attr dtype: The `dtype` of the serialized `SparseTensor` objects.
-@inlinable
-public static func deserializeManySparse<Dtype: TensorFlowScalar>(
-  serializedSparse: StringTensor
-) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
-  let op = TFE_Op("DeserializeManySparse")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(serializedSparse)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Deserialize `SparseTensor` objects.
-///
-/// The input `serialized_sparse` must have the shape `[?, ?, ..., ?, 3]` where
-/// the last dimension stores serialized `SparseTensor` objects and the other N
-/// dimensions (N >= 0) correspond to a batch. The ranks of the original
-/// `SparseTensor` objects must all match. When the final `SparseTensor` is
-/// created, its rank is the rank of the incoming `SparseTensor` objects plus N;
-/// the sparse tensors have been concatenated along new dimensions, one for each
-/// batch.
-///
-/// The output `SparseTensor` object's shape values for the original dimensions
-/// are the max across the input `SparseTensor` objects' shape values for the
-/// corresponding dimensions. The new dimensions match the size of the batch.
-///
-/// The input `SparseTensor` objects' indices are assumed ordered in
-/// standard lexicographic order.  If this is not the case, after this
-/// step run `SparseReorder` to restore index ordering.
-///
-/// For example, if the serialized input is a `[2 x 3]` matrix representing two
-/// original `SparseTensor` objects:
-///
-///     index = [ 0]
-///             [10]
-///             [20]
-///     values = [1, 2, 3]
-///     shape = [50]
-///
-/// and
-///
-///     index = [ 2]
-///             [10]
-///     values = [4, 5]
-///     shape = [30]
-///
-/// then the final deserialized `SparseTensor` will be:
-///
-///     index = [0  0]
-///             [0 10]
-///             [0 20]
-///             [1  2]
-///             [1 10]
-///     values = [1, 2, 3, 4, 5]
-///     shape = [2 50]
-///
-/// - Parameter serialized_sparse: The serialized `SparseTensor` objects. The last dimension
-///   must have 3 columns.
-///
-/// - Attr dtype: The `dtype` of the serialized `SparseTensor` objects.
-@inlinable
-public static func deserializeSparse<
-    Dtype: TensorFlowScalar,
-    Tserialized: TensorFlowScalar
->(
-  serializedSparse: Tensor<Tserialized>
-) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
-  let op = TFE_Op("DeserializeSparse")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("Tserialized", Tserialized.tensorFlowDataType)
-  let _ = op.addInput(serializedSparse)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Deserialize `SparseTensor` objects.
-///
-/// The input `serialized_sparse` must have the shape `[?, ?, ..., ?, 3]` where
-/// the last dimension stores serialized `SparseTensor` objects and the other N
-/// dimensions (N >= 0) correspond to a batch. The ranks of the original
-/// `SparseTensor` objects must all match. When the final `SparseTensor` is
-/// created, its rank is the rank of the incoming `SparseTensor` objects plus N;
-/// the sparse tensors have been concatenated along new dimensions, one for each
-/// batch.
-///
-/// The output `SparseTensor` object's shape values for the original dimensions
-/// are the max across the input `SparseTensor` objects' shape values for the
-/// corresponding dimensions. The new dimensions match the size of the batch.
-///
-/// The input `SparseTensor` objects' indices are assumed ordered in
-/// standard lexicographic order.  If this is not the case, after this
-/// step run `SparseReorder` to restore index ordering.
-///
-/// For example, if the serialized input is a `[2 x 3]` matrix representing two
-/// original `SparseTensor` objects:
-///
-///     index = [ 0]
-///             [10]
-///             [20]
-///     values = [1, 2, 3]
-///     shape = [50]
-///
-/// and
-///
-///     index = [ 2]
-///             [10]
-///     values = [4, 5]
-///     shape = [30]
-///
-/// then the final deserialized `SparseTensor` will be:
-///
-///     index = [0  0]
-///             [0 10]
-///             [0 20]
-///             [1  2]
-///             [1 10]
-///     values = [1, 2, 3, 4, 5]
-///     shape = [2 50]
-///
-/// - Parameter serialized_sparse: The serialized `SparseTensor` objects. The last dimension
-///   must have 3 columns.
-///
-/// - Attr dtype: The `dtype` of the serialized `SparseTensor` objects.
-@inlinable
-public static func deserializeSparse<Dtype: TensorFlowScalar>(
-  serializedSparse: StringTensor
-) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
-  let op = TFE_Op("DeserializeSparse")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("Tserialized", TensorDataType(TF_STRING))
-  let _ = op.addInput(serializedSparse)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Deletes the resource specified by the handle.
-///
-/// All subsequent operations using the resource will result in a NotFound
-/// error status.
-///
-/// - Parameter resource: handle to the resource to delete.
-///
-/// - Attr ignore_lookup_error: whether to ignore the error when the resource
-///   doesn't exist.
-@inlinable
-public static func destroyResourceOp(
-  resource: ResourceHandle,
-  ignoreLookupError: Bool = true
-) {
-  let op = TFE_Op("DestroyResourceOp")
-  op.setAttr("ignore_lookup_error", ignoreLookupError)
-  let _ = op.addInput(resource)
-  op.execute()
-}
-
-@inlinable
-public static func devicePlacementOp(
-) -> StringTensor {
-  let op = TFE_Op("DevicePlacementOp")
-  
-  return op.execute(Int(1))
-}
-
-/// Returns a diagonal tensor with a given diagonal values.
-///
-/// Given a `diagonal`, this operation returns a tensor with the `diagonal` and
-/// everything else padded with zeros. The diagonal is computed as follows:
-///
-/// Assume `diagonal` has dimensions [D1,..., Dk], then the output is a tensor of
-/// rank 2k with dimensions [D1,..., Dk, D1,..., Dk] where:
-///
-/// `output[i1,..., ik, i1,..., ik] = diagonal[i1, ..., ik]` and 0 everywhere else.
-///
-/// For example:
-///
-/// ```
-/// # 'diagonal' is [1, 2, 3, 4]
-/// tf.diag(diagonal) ==> [[1, 0, 0, 0]
-///                        [0, 2, 0, 0]
-///                        [0, 0, 3, 0]
-///                        [0, 0, 0, 4]]
-/// ```
-///
-/// - Parameter diagonal: Rank k tensor where k is at most 1.
-@inlinable
-public static func diag<T: Numeric & TensorFlowScalar>(
-  diagonal: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Diag")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(diagonal)
-  return op.execute(Int(1))
-}
-
-/// Returns the diagonal part of the tensor.
-///
-/// This operation returns a tensor with the `diagonal` part
-/// of the `input`. The `diagonal` part is computed as follows:
-///
-/// Assume `input` has dimensions `[D1,..., Dk, D1,..., Dk]`, then the output is a
-/// tensor of rank `k` with dimensions `[D1,..., Dk]` where:
-///
-/// `diagonal[i1,..., ik] = input[i1, ..., ik, i1,..., ik]`.
-///
-/// For example:
-///
-/// ```
-/// # 'input' is [[1, 0, 0, 0]
-///               [0, 2, 0, 0]
-///               [0, 0, 3, 0]
-///               [0, 0, 0, 4]]
-///
-/// tf.diag_part(input) ==> [1, 2, 3, 4]
-/// ```
-///
-/// - Parameter input: Rank k tensor where k is even and not zero.
-///
-/// - Output diagonal: The extracted diagonal.
-@inlinable
-public static func diagPart<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("DiagPart")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Computes Psi, the derivative of Lgamma (the log of the absolute value of
-///
-/// `Gamma(x)`), element-wise.
-@inlinable
-public static func digamma<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Digamma")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the grayscale dilation of 4-D `input` and 3-D `filter` tensors.
-///
-/// The `input` tensor has shape `[batch, in_height, in_width, depth]` and the
-/// `filter` tensor has shape `[filter_height, filter_width, depth]`, i.e., each
-/// input channel is processed independently of the others with its own structuring
-/// function. The `output` tensor has shape
-/// `[batch, out_height, out_width, depth]`. The spatial dimensions of the output
-/// tensor depend on the `padding` algorithm. We currently only support the default
-/// "NHWC" `data_format`.
-///
-/// In detail, the grayscale morphological 2-D dilation is the max-sum correlation
-/// (for consistency with `conv2d`, we use unmirrored filters):
-///
-///     output[b, y, x, c] =
-///        max_{dy, dx} input[b,
-///                           strides[1] * y + rates[1] * dy,
-///                           strides[2] * x + rates[2] * dx,
-///                           c] +
-///                     filter[dy, dx, c]
-///
-/// Max-pooling is a special case when the filter has size equal to the pooling
-/// kernel size and contains all zeros.
-///
-/// Note on duality: The dilation of `input` by the `filter` is equal to the
-/// negation of the erosion of `-input` by the reflected `filter`.
-///
-/// - Parameters:
-///   - input: 4-D with shape `[batch, in_height, in_width, depth]`.
-///   - filter: 3-D with shape `[filter_height, filter_width, depth]`.
-///
-/// - Attrs:
-///   - strides: The stride of the sliding window for each dimension of the input
-///     tensor. Must be: `[1, stride_height, stride_width, 1]`.
-///   - rates: The input stride for atrous morphological dilation. Must be:
-///     `[1, rate_height, rate_width, 1]`.
-///   - padding: The type of padding algorithm to use.
-///
-/// - Output output: 4-D with shape `[batch, out_height, out_width, depth]`.
-@inlinable
-public static func dilation2D<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  filter: Tensor<T>,
-  strides: [Int32],
-  rates: [Int32],
-  padding: Padding
-) -> Tensor<T> {
-  let op = TFE_Op("Dilation2D")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("rates", rates)
-  op.setAttr("padding", padding.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient of morphological 2-D dilation with respect to the filter.
-///
-/// - Parameters:
-///   - input: 4-D with shape `[batch, in_height, in_width, depth]`.
-///   - filter: 3-D with shape `[filter_height, filter_width, depth]`.
-///   - out_backprop: 4-D with shape `[batch, out_height, out_width, depth]`.
-///
-/// - Attrs:
-///   - strides: 1-D of length 4. The stride of the sliding window for each dimension of
-///     the input tensor. Must be: `[1, stride_height, stride_width, 1]`.
-///   - rates: 1-D of length 4. The input stride for atrous morphological dilation.
-///     Must be: `[1, rate_height, rate_width, 1]`.
-///   - padding: The type of padding algorithm to use.
-///
-/// - Output filter_backprop: 3-D with shape `[filter_height, filter_width, depth]`.
-@inlinable
-public static func dilation2DBackpropFilter<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  filter: Tensor<T>,
-  outBackprop: Tensor<T>,
-  strides: [Int32],
-  rates: [Int32],
-  padding: Padding
-) -> Tensor<T> {
-  let op = TFE_Op("Dilation2DBackpropFilter")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("rates", rates)
-  op.setAttr("padding", padding.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(outBackprop)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient of morphological 2-D dilation with respect to the input.
-///
-/// - Parameters:
-///   - input: 4-D with shape `[batch, in_height, in_width, depth]`.
-///   - filter: 3-D with shape `[filter_height, filter_width, depth]`.
-///   - out_backprop: 4-D with shape `[batch, out_height, out_width, depth]`.
-///
-/// - Attrs:
-///   - strides: 1-D of length 4. The stride of the sliding window for each dimension of
-///     the input tensor. Must be: `[1, stride_height, stride_width, 1]`.
-///   - rates: 1-D of length 4. The input stride for atrous morphological dilation.
-///     Must be: `[1, rate_height, rate_width, 1]`.
-///   - padding: The type of padding algorithm to use.
-///
-/// - Output in_backprop: 4-D with shape `[batch, in_height, in_width, depth]`.
-@inlinable
-public static func dilation2DBackpropInput<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  filter: Tensor<T>,
-  outBackprop: Tensor<T>,
-  strides: [Int32],
-  rates: [Int32],
-  padding: Padding
-) -> Tensor<T> {
-  let op = TFE_Op("Dilation2DBackpropInput")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("rates", rates)
-  op.setAttr("padding", padding.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(outBackprop)
-  return op.execute(Int(1))
-}
-
-/// Returns x / y element-wise.
-///
-/// *NOTE*: `Div` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func div<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Div")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns 0 if the denominator is zero.
-///
-///
-/// *NOTE*: `DivNoNan` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func divNoNan<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("DivNoNan")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Draw bounding boxes on a batch of images.
-///
-/// Outputs a copy of `images` but draws on top of the pixels zero or more bounding
-/// boxes specified by the locations in `boxes`. The coordinates of the each
-/// bounding box in `boxes` are encoded as `[y_min, x_min, y_max, x_max]`. The
-/// bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
-/// height of the underlying image.
-///
-/// For example, if an image is 100 x 200 pixels (height x width) and the bounding
-/// box is `[0.1, 0.2, 0.5, 0.9]`, the upper-left and bottom-right coordinates of
-/// the bounding box will be `(40, 10)` to `(180, 50)` (in (x,y) coordinates).
-///
-/// Parts of the bounding box may fall outside the image.
-///
-/// - Parameters:
-///   - images: 4-D with shape `[batch, height, width, depth]`. A batch of images.
-///   - boxes: 3-D with shape `[batch, num_bounding_boxes, 4]` containing bounding
-///     boxes.
-///
-/// - Output output: 4-D with the same shape as `images`. The batch of input images with
-///   bounding boxes drawn on the images.
-@inlinable
-public static func drawBoundingBoxes<T: FloatingPoint & TensorFlowScalar>(
-  images: Tensor<T>,
-  boxes: Tensor<Float>
-) -> Tensor<T> {
-  let op = TFE_Op("DrawBoundingBoxes")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(images)
-  let _ = op.addInput(boxes)
-  return op.execute(Int(1))
-}
-
-/// Draw bounding boxes on a batch of images.
-///
-/// Outputs a copy of `images` but draws on top of the pixels zero or more bounding
-/// boxes specified by the locations in `boxes`. The coordinates of the each
-/// bounding box in `boxes` are encoded as `[y_min, x_min, y_max, x_max]`. The
-/// bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
-/// height of the underlying image.
-///
-/// For example, if an image is 100 x 200 pixels (height x width) and the bounding
-/// box is `[0.1, 0.2, 0.5, 0.9]`, the upper-left and bottom-right coordinates of
-/// the bounding box will be `(40, 10)` to `(100, 50)` (in (x,y) coordinates).
-///
-/// Parts of the bounding box may fall outside the image.
-///
-/// - Parameters:
-///   - images: 4-D with shape `[batch, height, width, depth]`. A batch of images.
-///   - boxes: 3-D with shape `[batch, num_bounding_boxes, 4]` containing bounding
-///     boxes.
-///   - colors: 2-D. A list of RGBA colors to cycle through for the boxes.
-///
-/// - Output output: 4-D with the same shape as `images`. The batch of input images with
-///   bounding boxes drawn on the images.
-@inlinable
-public static func drawBoundingBoxesV2<T: FloatingPoint & TensorFlowScalar>(
-  images: Tensor<T>,
-  boxes: Tensor<Float>,
-  colors: Tensor<Float>
-) -> Tensor<T> {
-  let op = TFE_Op("DrawBoundingBoxesV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(images)
-  let _ = op.addInput(boxes)
-  let _ = op.addInput(colors)
-  return op.execute(Int(1))
-}
-
-/// Partitions `data` into `num_partitions` tensors using indices from `partitions`.
-///
-/// For each index tuple `js` of size `partitions.ndim`, the slice `data[js, ...]`
-/// becomes part of `outputs[partitions[js]]`.  The slices with `partitions[js] = i`
-/// are placed in `outputs[i]` in lexicographic order of `js`, and the first
-/// dimension of `outputs[i]` is the number of entries in `partitions` equal to `i`.
-/// In detail,
-///
-/// ```python
-///     outputs[i].shape = [sum(partitions == i)] + data.shape[partitions.ndim:]
-///
-///     outputs[i] = pack([data[js, ...] for js if partitions[js] == i])
-/// ```
-///
-/// `data.shape` must start with `partitions.shape`.
-///
-/// For example:
-///
-/// ```python
-///     # Scalar partitions.
-///     partitions = 1
-///     num_partitions = 2
-///     data = [10, 20]
-///     outputs[0] = []  # Empty with shape [0, 2]
-///     outputs[1] = [[10, 20]]
-///
-///     # Vector partitions.
-///     partitions = [0, 0, 1, 1, 0]
-///     num_partitions = 2
-///     data = [10, 20, 30, 40, 50]
-///     outputs[0] = [10, 20, 50]
-///     outputs[1] = [30, 40]
-/// ```
-///
-/// See `dynamic_stitch` for an example on how to merge partitions back.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/DynamicPartition.png" alt>
-/// </div>
-///
-/// - Parameter partitions: Any shape.  Indices in the range `[0, num_partitions)`.
-///
-/// - Attr num_partitions: The number of partitions to output.
-@inlinable
-public static func dynamicPartition<T: TensorFlowScalar>(
-  data: Tensor<T>,
-  partitions: Tensor<Int32>,
-  numPartitions: Int64
-) -> [Tensor<T>] {
-  let op = TFE_Op("DynamicPartition")
-  op.setAttr("num_partitions", numPartitions)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(partitions)
-  return op.execute(Int(numPartitions))
-}
-
-/// Interleave the values from the `data` tensors into a single tensor.
-///
-/// Builds a merged tensor such that
-///
-/// ```python
-///     merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
-/// ```
-///
-/// For example, if each `indices[m]` is scalar or vector, we have
-///
-/// ```python
-///     # Scalar indices:
-///     merged[indices[m], ...] = data[m][...]
-///
-///     # Vector indices:
-///     merged[indices[m][i], ...] = data[m][i, ...]
-/// ```
-///
-/// Each `data[i].shape` must start with the corresponding `indices[i].shape`,
-/// and the rest of `data[i].shape` must be constant w.r.t. `i`.  That is, we
-/// must have `data[i].shape = indices[i].shape + constant`.  In terms of this
-/// `constant`, the output shape is
-///
-///     merged.shape = [max(indices)] + constant
-///
-/// Values are merged in order, so if an index appears in both `indices[m][i]` and
-/// `indices[n][j]` for `(m,i) < (n,j)` the slice `data[n][j]` will appear in the
-/// merged result. If you do not need this guarantee, ParallelDynamicStitch might
-/// perform better on some devices.
-///
-/// For example:
-///
-/// ```python
-///     indices[0] = 6
-///     indices[1] = [4, 1]
-///     indices[2] = [[5, 2], [0, 3]]
-///     data[0] = [61, 62]
-///     data[1] = [[41, 42], [11, 12]]
-///     data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
-///     merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
-///               [51, 52], [61, 62]]
-/// ```
-///
-/// This method can be used to merge partitions created by `dynamic_partition`
-/// as illustrated on the following example:
-///
-/// ```python
-///     # Apply function (increments x_i) on elements for which a certain condition
-///     # apply (x_i != -1 in this example).
-///     x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
-///     condition_mask=tf.not_equal(x,tf.constant(-1.))
-///     partitioned_data = tf.dynamic_partition(
-///         x, tf.cast(condition_mask, tf.int32) , 2)
-///     partitioned_data[1] = partitioned_data[1] + 1.0
-///     condition_indices = tf.dynamic_partition(
-///         tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
-///     x = tf.dynamic_stitch(condition_indices, partitioned_data)
-///     # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
-///     # unchanged.
-/// ```
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/DynamicStitch.png" alt>
-/// </div>
-@inlinable
-public static func dynamicStitch<T: TensorFlowScalar>(
-  indices: [Tensor<Int32>],
-  data: [Tensor<T>]
-) -> Tensor<T> {
-  let op = TFE_Op("DynamicStitch")
-  op.setAttr("N", indices.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInputList(indices)
-  let _ = op.addInputList(data)
-  return op.execute(Int(1))
-}
-
-/// 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.
-@inlinable
-public static func eagerPyFunc<
-    Tin: TensorArrayProtocol,
-    Tout: TensorGroup
->(
-  _ input: Tin,
-  token: String
-) -> Tout {
-  let op = TFE_Op("EagerPyFunc")
-  op.setAttr("token", token)
-  op.setAttr("Tin", input._typeList)
-  op.setAttr("Tout", Tout._typeList)
-  let _ = op.addInputList(input)
-  return op.execute(Int(Tout._typeList.count))
-}
-
-/// Computes the (possibly normalized) Levenshtein Edit Distance.
-///
-/// The inputs are variable-length sequences provided by SparseTensors
-///   (hypothesis_indices, hypothesis_values, hypothesis_shape)
-/// and
-///   (truth_indices, truth_values, truth_shape).
-///
-/// The inputs are:
-///
-/// - Parameters:
-///   - hypothesis_indices: The indices of the hypothesis list SparseTensor.
-///     This is an N x R int64 matrix.
-///   - hypothesis_values: The values of the hypothesis list SparseTensor.
-///     This is an N-length vector.
-///   - hypothesis_shape: The shape of the hypothesis list SparseTensor.
-///     This is an R-length vector.
-///   - truth_indices: The indices of the truth list SparseTensor.
-///     This is an M x R int64 matrix.
-///   - truth_values: The values of the truth list SparseTensor.
-///     This is an M-length vector.
-///   - truth_shape: truth indices, vector.
-///
-/// - Attr normalize: boolean (if true, edit distances are normalized by length of truth).
-///
-///   The output is:
-///
-/// - Output output: A dense float tensor with rank R - 1.
-///
-///   For the example input:
-///
-///       // hypothesis represents a 2x1 matrix with variable-length values:
-///       //   (0,0) = ["a"]
-///       //   (1,0) = ["b"]
-///       hypothesis_indices = [[0, 0, 0],
-///                             [1, 0, 0]]
-///       hypothesis_values = ["a", "b"]
-///       hypothesis_shape = [2, 1, 1]
-///
-///       // truth represents a 2x2 matrix with variable-length values:
-///       //   (0,0) = []
-///       //   (0,1) = ["a"]
-///       //   (1,0) = ["b", "c"]
-///       //   (1,1) = ["a"]
-///       truth_indices = [[0, 1, 0],
-///                        [1, 0, 0],
-///                        [1, 0, 1],
-///                        [1, 1, 0]]
-///       truth_values = ["a", "b", "c", "a"]
-///       truth_shape = [2, 2, 2]
-///       normalize = true
-///
-///   The output will be:
-///
-///       // output is a 2x2 matrix with edit distances normalized by truth lengths.
-///       output = [[inf, 1.0],  // (0,0): no truth, (0,1): no hypothesis
-///                 [0.5, 1.0]]  // (1,0): addition, (1,1): no hypothesis
-@inlinable
-public static func editDistance<T: TensorFlowScalar>(
-  hypothesisIndices: Tensor<Int64>,
-  hypothesisValues: Tensor<T>,
-  hypothesisShape: Tensor<Int64>,
-  truthIndices: Tensor<Int64>,
-  truthValues: Tensor<T>,
-  truthShape: Tensor<Int64>,
-  normalize: Bool = true
-) -> Tensor<Float> {
-  let op = TFE_Op("EditDistance")
-  op.setAttr("normalize", normalize)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(hypothesisIndices)
-  let _ = op.addInput(hypothesisValues)
-  let _ = op.addInput(hypothesisShape)
-  let _ = op.addInput(truthIndices)
-  let _ = op.addInput(truthValues)
-  let _ = op.addInput(truthShape)
-  return op.execute(Int(1))
-}
-
-/// Computes exponential linear: `exp(features) - 1` if < 0, `features` otherwise.
-///
-/// See [Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)
-/// ](http://arxiv.org/abs/1511.07289)
-@inlinable
-public static func elu<T: FloatingPoint & TensorFlowScalar>(
-  features: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Elu")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(features)
-  return op.execute(Int(1))
-}
-
-/// Computes gradients for the exponential linear (Elu) operation.
-///
-/// - Parameters:
-///   - gradients: The backpropagated gradients to the corresponding Elu operation.
-///   - outputs: The outputs of the corresponding Elu operation.
-///
-/// - Output backprops: The gradients: `gradients * (outputs + 1)` if outputs < 0,
-///   `gradients` otherwise.
-@inlinable
-public static func eluGrad<T: FloatingPoint & TensorFlowScalar>(
-  gradients: Tensor<T>,
-  outputs: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("EluGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(gradients)
-  let _ = op.addInput(outputs)
-  return op.execute(Int(1))
-}
-
-/// Creates a tensor with the given shape.
-///
-/// This operation creates a tensor of `shape` and `dtype`.
-///
-/// - Parameter shape: 1-D. Represents the shape of the output tensor.
-///
-/// - Attr init: If True, initialize the returned tensor with the default value of dtype.  Otherwise, the implementation is free not to initializethe tensor's content.
-///
-/// - Output output: A `Tensor` of type `T`.
-@inlinable
-public static func empty<Dtype: TensorFlowScalar>(
-  shape: Tensor<Int32>,
-  init_: Bool = false
-) -> Tensor<Dtype> {
-  let op = TFE_Op("Empty")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("init", init_)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Creates and returns an empty tensor list.
-///
-/// All list elements must be tensors of dtype element_dtype and shape compatible
-/// with element_shape.
-///
-/// handle: an empty tensor list.
-/// element_dtype: the type of elements in the list.
-/// element_shape: a shape compatible with that of elements in the list.
-@inlinable
-public static func emptyTensorList<ShapeType: BinaryInteger & TensorFlowScalar>(
-  elementShape: Tensor<ShapeType>,
-  maxNumElements: Tensor<Int32>,
-  elementDtype: TensorDataType
-) -> VariantHandle {
-  let op = TFE_Op("EmptyTensorList")
-  op.setAttr("element_dtype", elementDtype)
-  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
-  let _ = op.addInput(elementShape)
-  let _ = op.addInput(maxNumElements)
-  return op.execute(Int(1))
-}
-
-/// Encode strings into web-safe base64 format.
-///
-/// Refer to the following article for more information on base64 format:
-/// en.wikipedia.org/wiki/Base64. Base64 strings may have padding with '=' at the
-/// end so that the encoded has length multiple of 4. See Padding section of the
-/// link above.
-///
-/// Web-safe means that the encoder uses - and _ instead of + and /.
-///
-/// - Parameter input: Strings to be encoded.
-///
-/// - Attr pad: Bool whether padding is applied at the ends.
-///
-/// - Output output: Input strings encoded in base64.
-@inlinable
-public static func encodeBase64(
-  _ input: StringTensor,
-  pad: Bool = false
-) -> StringTensor {
-  let op = TFE_Op("EncodeBase64")
-  op.setAttr("pad", pad)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// JPEG-encode an image.
-///
-/// `image` is a 3-D uint8 Tensor of shape `[height, width, channels]`.
-///
-/// The attr `format` can be used to override the color format of the encoded
-/// output.  Values can be:
-///
-/// *   `''`: Use a default format based on the number of channels in the image.
-/// *   `grayscale`: Output a grayscale JPEG image.  The `channels` dimension
-///     of `image` must be 1.
-/// *   `rgb`: Output an RGB JPEG image. The `channels` dimension
-///     of `image` must be 3.
-///
-/// If `format` is not specified or is the empty string, a default format is picked
-/// in function of the number of channels in `image`:
-///
-/// *   1: Output a grayscale image.
-/// *   3: Output an RGB image.
-///
-/// - Parameter image: 3-D with shape `[height, width, channels]`.
-///
-/// - Attrs:
-///   - format: Per pixel image format.
-///   - quality: Quality of the compression from 0 to 100 (higher is better and slower).
-///   - progressive: If True, create a JPEG that loads progressively (coarse to fine).
-///   - optimize_size: If True, spend CPU/RAM to reduce size with no quality change.
-///   - chroma_downsampling: See http://en.wikipedia.org/wiki/Chroma_subsampling.
-///   - density_unit: Unit used to specify `x_density` and `y_density`:
-///     pixels per inch (`'in'`) or centimeter (`'cm'`).
-///   - x_density: Horizontal pixels per density unit.
-///   - y_density: Vertical pixels per density unit.
-///   - xmp_metadata: If not empty, embed this XMP metadata in the image header.
-///
-/// - Output contents: 0-D. JPEG-encoded image.
-@inlinable
-public static func encodeJpeg(
-  image: Tensor<UInt8>,
-  format: Format,
-  quality: Int64 = 95,
-  progressive: Bool = false,
-  optimizeSize: Bool = false,
-  chromaDownsampling: Bool = true,
-  densityUnit: DensityUnit = .in_,
-  xDensity: Int64 = 300,
-  yDensity: Int64 = 300,
-  xmpMetadata: String
-) -> StringTensor {
-  let op = TFE_Op("EncodeJpeg")
-  op.setAttr("format", format.cName)
-  op.setAttr("quality", quality)
-  op.setAttr("progressive", progressive)
-  op.setAttr("optimize_size", optimizeSize)
-  op.setAttr("chroma_downsampling", chromaDownsampling)
-  op.setAttr("density_unit", densityUnit.cName)
-  op.setAttr("x_density", xDensity)
-  op.setAttr("y_density", yDensity)
-  op.setAttr("xmp_metadata", xmpMetadata)
-  let _ = op.addInput(image)
-  return op.execute(Int(1))
-}
-
-/// JPEG encode input image with provided compression quality.
-///
-/// `image` is a 3-D uint8 Tensor of shape `[height, width, channels]`.
-/// `quality` is an int32 jpeg compression quality value between 0 and 100.
-///
-///
-/// - Parameters:
-///   - images: Images to adjust.  At least 3-D.
-///   - quality: An int quality to encode to.
-///
-/// - Output contents: 0-D. JPEG-encoded image.
-@inlinable
-public static func encodeJpegVariableQuality(
-  images: Tensor<UInt8>,
-  quality: Tensor<Int32>
-) -> StringTensor {
-  let op = TFE_Op("EncodeJpegVariableQuality")
-  let _ = op.addInput(images)
-  let _ = op.addInput(quality)
-  return op.execute(Int(1))
-}
-
-/// PNG-encode an image.
-///
-/// `image` is a 3-D uint8 or uint16 Tensor of shape `[height, width, channels]`
-/// where `channels` is:
-///
-/// *   1: for grayscale.
-/// *   2: for grayscale + alpha.
-/// *   3: for RGB.
-/// *   4: for RGBA.
-///
-/// The ZLIB compression level, `compression`, can be -1 for the PNG-encoder
-/// default or a value from 0 to 9.  9 is the highest compression level, generating
-/// the smallest output, but is slower.
-///
-/// - Parameter image: 3-D with shape `[height, width, channels]`.
-///
-/// - Attr compression: Compression level.
-///
-/// - Output contents: 0-D. PNG-encoded image.
-@inlinable
-public static func encodePng<T: UnsignedInteger & TensorFlowScalar>(
-  image: Tensor<T>,
-  compression: Int64 = -1
-) -> StringTensor {
-  let op = TFE_Op("EncodePng")
-  op.setAttr("compression", compression)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(image)
-  return op.execute(Int(1))
-}
-
-/// The op serializes protobuf messages provided in the input tensors.
-///
-/// The types of the tensors in `values` must match the schema for the
-/// fields specified in `field_names`. All the tensors in `values` must
-/// have a common shape prefix, *batch_shape*.
-///
-/// The `sizes` tensor specifies repeat counts for each field.  The repeat
-/// count (last dimension) of a each tensor in `values` must be greater
-/// than or equal to corresponding repeat count in `sizes`.
-///
-/// A `message_type` name must be provided to give context for the field
-/// names. The actual message descriptor can be looked up either in the
-/// linked-in descriptor pool or a filename provided by the caller using
-/// the `descriptor_source` attribute.
-///
-/// The `descriptor_source` attribute selects a source of protocol
-/// descriptors to consult when looking up `message_type`. This may be a
-/// filename containing a serialized `FileDescriptorSet` message,
-/// or the special value `local://`, in which case only descriptors linked
-/// into the code will be searched; the filename can be on any filesystem
-/// accessible to TensorFlow.
-///
-/// You can build a `descriptor_source` file using the `--descriptor_set_out`
-/// and `--include_imports` options to the protocol compiler `protoc`.
-///
-/// The `local://` database only covers descriptors linked into the
-/// code via C++ libraries, not Python imports. You can link in a proto descriptor
-/// by creating a cc_library target with alwayslink=1.
-///
-/// There are a few special cases in the value mapping:
-///
-/// Submessage and group fields must be pre-serialized as TensorFlow strings.
-///
-/// TensorFlow lacks support for unsigned int64s, so they must be
-/// represented as `tf.int64` with the same twos-complement bit pattern
-/// (the obvious way).
-///
-/// Unsigned int32 values can be represented exactly with `tf.int64`, or
-/// with sign wrapping if the input is of type `tf.int32`.
-///
-/// - Parameters:
-///   - sizes: Tensor of int32 with shape `[batch_shape, len(field_names)]`.
-///   - values: List of tensors containing values for the corresponding field.
-///
-/// - Attrs:
-///   - field_names: List of strings containing proto field names.
-///   - message_type: Name of the proto message type to decode.
-///   - Tinput_types: The input types.
-///
-/// - Output bytes: Tensor of serialized protos with shape `batch_shape`.
-@inlinable
-public static func encodeProto<TinputTypes: TensorArrayProtocol>(
-  sizes: Tensor<Int32>,
-  _ values: TinputTypes,
-  fieldNames: [String],
-  messageType: String,
-  descriptorSource: String = "local://"
-) -> StringTensor {
-  let op = TFE_Op("EncodeProto")
-  op.setAttr("field_names", fieldNames)
-  op.setAttr("message_type", messageType)
-  op.setAttr("descriptor_source", descriptorSource)
-  op.setAttr("Tinput_types", values._typeList)
-  let _ = op.addInput(sizes)
-  let _ = op.addInputList(values)
-  return op.execute(Int(1))
-}
-
-/// Encode audio data using the WAV file format.
-///
-/// This operation will generate a string suitable to be saved out to create a .wav
-/// audio file. It will be encoded in the 16-bit PCM format. It takes in float
-/// values in the range -1.0f to 1.0f, and any outside that value will be clamped to
-/// that range.
-///
-/// `audio` is a 2-D float Tensor of shape `[length, channels]`.
-/// `sample_rate` is a scalar Tensor holding the rate to use (e.g. 44100).
-///
-/// - Parameters:
-///   - audio: 2-D with shape `[length, channels]`.
-///   - sample_rate: Scalar containing the sample frequency.
-///
-/// - Output contents: 0-D. WAV-encoded file contents.
-@inlinable
-public static func encodeWav(
-  audio: Tensor<Float>,
-  sampleRate: Tensor<Int32>
-) -> StringTensor {
-  let op = TFE_Op("EncodeWav")
-  let _ = op.addInput(audio)
-  let _ = op.addInput(sampleRate)
-  return op.execute(Int(1))
-}
-
-/// An op that enqueues a list of input batch tensors to TPUEmbedding.
-///
-/// - Parameters:
-///   - batch: A list of 1D tensors, one for each embedding table, containing the
-///     indices into the tables.
-///   - mode_override: A string input that overrides the mode specified in the
-///     TPUEmbeddingConfiguration. Supported values are {'unspecified', 'inference',
-///     'training', 'backward_pass_only'}. When set to 'unspecified', the mode set
-///     in TPUEmbeddingConfiguration is used, otherwise mode_override is used.
-///
-/// - Attr device_ordinal: The TPU device to use. Should be >= 0 and less than the number
-///   of TPU cores in the task on which the node is placed.
-@inlinable
-public static func enqueueTPUEmbeddingIntegerBatch(
-  batch: [Tensor<Int32>],
-  modeOverride: StringTensor,
-  deviceOrdinal: Int64 = -1
-) {
-  let op = TFE_Op("EnqueueTPUEmbeddingIntegerBatch")
-  op.setAttr("N", batch.count)
-  op.setAttr("device_ordinal", deviceOrdinal)
-  let _ = op.addInputList(batch)
-  let _ = op.addInput(modeOverride)
-  op.execute()
-}
-
-/// An op that enqueues TPUEmbedding input indices from a SparseTensor.
-///
-/// This Op eases the porting of code that uses embedding_lookup_sparse(),
-/// although some Python preprocessing of the SparseTensor arguments to
-/// embedding_lookup_sparse() is required to produce the arguments to this Op,
-/// since only a single EnqueueTPUEmbeddingSparseBatch Op is allowed per training
-/// step.
-///
-/// The tensors at corresponding positions in the three input lists
-/// must have the same shape, i.e. rank 1 with dim_size() equal to the total
-/// number of lookups into the table described by the corresponding table_id.
-///
-/// - Parameters:
-///   - sample_indices: A list of rank 1 Tensors specifying the training example and
-///     feature to which the corresponding embedding_indices and aggregation_weights
-///     values belong. sample_indices[i] must equal b * nf + f, where nf is the
-///     number of features from the corresponding table, f is in [0, nf), and
-///     b is in [0, batch size).
-///   - embedding_indices: A list of rank 1 Tensors, indices into the embedding tables.
-///   - aggregation_weights: A list of rank 1 Tensors containing per sample -- i.e. per
-///     (training example, feature) -- aggregation weights.
-///   - mode_override: A string input that overrides the mode specified in the
-///     TPUEmbeddingConfiguration. Supported values are {'unspecified', 'inference',
-///     'training', 'backward_pass_only'}. When set to 'unspecified', the mode set
-///     in TPUEmbeddingConfiguration is used, otherwise mode_override is used.
-///
-/// - Attrs:
-///   - device_ordinal: The TPU device to use. Should be >= 0 and less than the number
-///     of TPU cores in the task on which the node is placed.
-///   - combiners: A list of string scalars, one for each embedding table that specify
-///     how to normalize the embedding activations after weighted summation.
-///     Supported combiners are 'mean', 'sum', or 'sqrtn'. It is invalid to have
-///     the sum of the weights be 0 for 'mean' or the sum of the squared weights be
-///     0 for 'sqrtn'. If combiners isn't passed, the default is to use 'sum' for
-///     all tables.
-@inlinable
-public static func enqueueTPUEmbeddingSparseBatch<
-    T1: BinaryInteger & TensorFlowScalar,
-    T2: BinaryInteger & TensorFlowScalar,
-    T3: FloatingPoint & TensorFlowScalar
->(
-  sampleIndices: [Tensor<T1>],
-  embeddingIndices: [Tensor<T2>],
-  aggregationWeights: [Tensor<T3>],
-  modeOverride: StringTensor,
-  deviceOrdinal: Int64 = -1,
-  combiners: [String]
-) {
-  let op = TFE_Op("EnqueueTPUEmbeddingSparseBatch")
-  op.setAttr("T1", T1.tensorFlowDataType)
-  op.setAttr("T2", T2.tensorFlowDataType)
-  op.setAttr("T3", T3.tensorFlowDataType)
-  op.setAttr("N", sampleIndices.count)
-  op.setAttr("device_ordinal", deviceOrdinal)
-  op.setAttr("combiners", combiners)
-  let _ = op.addInputList(sampleIndices)
-  let _ = op.addInputList(embeddingIndices)
-  let _ = op.addInputList(aggregationWeights)
-  let _ = op.addInput(modeOverride)
-  op.execute()
-}
-
-/// Eases the porting of code that uses tf.nn.embedding_lookup_sparse().
-///
-/// sample_indices[i], embedding_indices[i] and aggregation_weights[i] correspond
-/// to the ith feature. table_ids[i] indicates which embedding table to look up ith
-/// feature.
-///
-/// The tensors at corresponding positions in the three input lists (sample_indices,
-/// embedding_indices and aggregation_weights) must have the same shape, i.e. rank 1
-/// with dim_size() equal to the total number of lookups into the table described by
-/// the corresponding feature.
-///
-/// - Parameters:
-///   - sample_indices: A list of rank 1 Tensors specifying the training example to
-///     which the corresponding embedding_indices and aggregation_weights values
-///     belong. It corresponds to sp_ids.indices[:,0] in  embedding_lookup_sparse().
-///   - embedding_indices: A list of rank 1 Tensors, indices into the embedding tables.
-///     It corresponds to sp_ids.values in embedding_lookup_sparse().
-///   - aggregation_weights: A list of rank 1 Tensors containing per training example
-///     aggregation weights. It corresponds to sp_weights.values in
-///     embedding_lookup_sparse().
-///   - mode_override: A string input that overrides the mode specified in the
-///     TPUEmbeddingConfiguration. Supported values are {'unspecified', 'inference',
-///     'training', 'backward_pass_only'}. When set to 'unspecified', the mode set
-///     in TPUEmbeddingConfiguration is used, otherwise mode_override is used.
-///
-/// - Attrs:
-///   - device_ordinal: The TPU device to use. Should be >= 0 and less than the number
-///     of TPU cores in the task on which the node is placed.
-///   - combiners: A list of string scalars, one for each embedding table that specify
-///     how to normalize the embedding activations after weighted summation.
-///     Supported combiners are 'mean', 'sum', or 'sqrtn'. It is invalid to have
-///     the sum of the weights be 0 for 'mean' or the sum of the squared weights be
-///     0 for 'sqrtn'. If combiners isn't passed, the default is to use 'sum' for
-///     all tables.
-///   - table_ids: A list of integers specifying the identifier of the embedding table
-///     (offset of TableDescriptor in the TPUEmbeddingConfiguration) to lookup the
-///     corresponding input. The ith input is looked up using table_ids[i]. The size
-///     of the table_ids list must be equal to that of sample_indices,
-///     embedding_indices and aggregation_weights.
-@inlinable
-public static func enqueueTPUEmbeddingSparseTensorBatch<
-    T1: BinaryInteger & TensorFlowScalar,
-    T2: BinaryInteger & TensorFlowScalar,
-    T3: FloatingPoint & TensorFlowScalar
->(
-  sampleIndices: [Tensor<T1>],
-  embeddingIndices: [Tensor<T2>],
-  aggregationWeights: [Tensor<T3>],
-  modeOverride: StringTensor,
-  deviceOrdinal: Int64 = -1,
-  combiners: [String],
-  tableIds: [Int32],
-  maxSequenceLengths: [Int32]
-) {
-  let op = TFE_Op("EnqueueTPUEmbeddingSparseTensorBatch")
-  op.setAttr("T1", T1.tensorFlowDataType)
-  op.setAttr("T2", T2.tensorFlowDataType)
-  op.setAttr("T3", T3.tensorFlowDataType)
-  op.setAttr("N", sampleIndices.count)
-  op.setAttr("device_ordinal", deviceOrdinal)
-  op.setAttr("combiners", combiners)
-  op.setAttr("table_ids", tableIds)
-  op.setAttr("max_sequence_lengths", maxSequenceLengths)
-  let _ = op.addInputList(sampleIndices)
-  let _ = op.addInputList(embeddingIndices)
-  let _ = op.addInputList(aggregationWeights)
-  let _ = op.addInput(modeOverride)
-  op.execute()
-}
-
-/// Ensures that the tensor's shape matches the expected shape.
-///
-/// Raises an error if the input tensor's shape does not match the specified shape.
-/// Returns the input tensor otherwise.
-///
-/// - Parameter input: A tensor, whose shape is to be validated.
-///
-/// - Attr shape: The expected (possibly partially specified) shape of the input tensor.
-///
-/// - Output output: A tensor with the same shape and contents as the input tensor or value.
-@inlinable
-public static func ensureShape<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  shape: TensorShape?
-) -> Tensor<T> {
-  let op = TFE_Op("EnsureShape")
-  op.setAttr("shape", shape)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Creates or finds a child frame, and makes `data` available to the child frame.
-///
-/// This op is used together with `Exit` to create loops in the graph.
-/// The unique `frame_name` is used by the `Executor` to identify frames. If
-/// `is_constant` is true, `output` is a constant in the child frame; otherwise
-/// it may be changed in the child frame. At most `parallel_iterations` iterations
-/// are run in parallel in the child frame.
-///
-/// - Parameter data: The tensor to be made available to the child frame.
-///
-/// - Attrs:
-///   - frame_name: The name of the child frame.
-///   - is_constant: If true, the output is constant within the child frame.
-///   - parallel_iterations: The number of iterations allowed to run in parallel.
-///
-/// - Output output: The same tensor as `data`.
-@inlinable
-public static func enter<T: TensorFlowScalar>(
-  data: Tensor<T>,
-  frameName: String,
-  isConstant: Bool = false,
-  parallelIterations: Int64 = 10
-) -> Tensor<T> {
-  let op = TFE_Op("Enter")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("frame_name", frameName)
-  op.setAttr("is_constant", isConstant)
-  op.setAttr("parallel_iterations", parallelIterations)
-  let _ = op.addInput(data)
-  return op.execute(Int(1))
-}
-
-/// Returns the truth value of (x == y) element-wise.
-///
-/// *NOTE*: `Equal` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func equal<T: TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<Bool> {
-  let op = TFE_Op("Equal")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns the truth value of (x == y) element-wise.
-///
-/// *NOTE*: `Equal` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func equal(
-  _ x: StringTensor,
-  _ y: StringTensor
-) -> Tensor<Bool> {
-  let op = TFE_Op("Equal")
-  op.setAttr("T", TensorDataType(TF_STRING))
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Computes the Gauss error function of `x` element-wise.
-@inlinable
-public static func erf<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Erf")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the complementary error function of `x` element-wise.
-@inlinable
-public static func erfc<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Erfc")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the euclidean norm of elements across dimensions of a tensor.
-///
-/// Reduces `input` along the dimensions given in `axis`. Unless
-/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-/// `axis`. If `keep_dims` is true, the reduced dimensions are
-/// retained with length 1.
-///
-/// - Parameters:
-///   - input: The tensor to reduce.
-///   - reduction_indices: The dimensions to reduce. Must be in the range
-///     `[-rank(input), rank(input))`.
-///
-/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-///
-/// - Output output: The reduced tensor.
-@inlinable
-public static func euclideanNorm<
-    T: Numeric & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  reductionIndices: Tensor<Tidx>,
-  keepDims: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("EuclideanNorm")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(reductionIndices)
-  return op.execute(Int(1))
-}
-
-/// Exits the current frame to its parent frame.
-///
-/// Exit makes its input `data` available to the parent frame.
-///
-/// - Parameter data: The tensor to be made available to the parent frame.
-///
-/// - Output output: The same tensor as `data`.
-@inlinable
-public static func exit<T: TensorFlowScalar>(
-  data: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Exit")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(data)
-  return op.execute(Int(1))
-}
-
-/// Computes exponential of x element-wise.  \\(y = e^x\\).
-@inlinable
-public static func exp<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Exp")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Inserts a dimension of 1 into a tensor's shape.
-///
-/// Given a tensor `input`, this operation inserts a dimension of 1 at the
-/// dimension index `axis` of `input`'s shape. The dimension index `axis` starts at
-/// zero; if you specify a negative number for `axis` it is counted backward from
-/// the end.
-///
-/// This operation is useful if you want to add a batch dimension to a single
-/// element. For example, if you have a single image of shape `[height, width,
-/// channels]`, you can make it a batch of 1 image with `expand_dims(image, 0)`,
-/// which will make the shape `[1, height, width, channels]`.
-///
-/// Other examples:
-///
-/// ```
-/// # 't' is a tensor of shape [2]
-/// shape(expand_dims(t, 0)) ==> [1, 2]
-/// shape(expand_dims(t, 1)) ==> [2, 1]
-/// shape(expand_dims(t, -1)) ==> [2, 1]
-///
-/// # 't2' is a tensor of shape [2, 3, 5]
-/// shape(expand_dims(t2, 0)) ==> [1, 2, 3, 5]
-/// shape(expand_dims(t2, 2)) ==> [2, 3, 1, 5]
-/// shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]
-/// ```
-///
-/// This operation requires that:
-///
-/// `-1-input.dims() <= dim <= input.dims()`
-///
-/// This operation is related to `squeeze()`, which removes dimensions of
-/// size 1.
-///
-/// - Parameter dim: 0-D (scalar). Specifies the dimension index at which to
-///   expand the shape of `input`. Must be in the range
-///   `[-rank(input) - 1, rank(input)]`.
-///
-/// - Output output: Contains the same data as `input`, but its shape has an additional
-///   dimension of size 1 added.
-@inlinable
-public static func expandDims<
-    T: TensorFlowScalar,
-    Tdim: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  dim: Tensor<Tdim>
-) -> Tensor<T> {
-  let op = TFE_Op("ExpandDims")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tdim", Tdim.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(dim)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func experimentalAssertNextDataset(
-  inputDataset: VariantHandle,
-  transformations: StringTensor,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalAssertNextDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(transformations)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that shards the input dataset.
-///
-/// Creates a dataset that shards the input dataset by num_workers, returning a
-/// sharded dataset for the index-th worker. This attempts to automatically shard
-/// a dataset by examining the Dataset graph and inserting a shard op before the
-/// inputs to a reader Dataset (e.g. CSVDataset, TFRecordDataset).
-///
-/// This dataset will throw a NotFound error if we cannot shard the dataset
-/// automatically.
-///
-/// - Parameters:
-///   - input_dataset: A variant tensor representing the input dataset.
-///   - num_workers: A scalar representing the number of workers to distribute this dataset across.
-///   - index: A scalar representing the index of the current worker out of num_workers.
-@inlinable
-public static func experimentalAutoShardDataset(
-  inputDataset: VariantHandle,
-  numWorkers: Tensor<Int64>,
-  index: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalAutoShardDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(numWorkers)
-  let _ = op.addInput(index)
-  return op.execute(Int(1))
-}
-
-/// Records the bytes size of each element of `input_dataset` in a StatsAggregator.
-@inlinable
-public static func experimentalBytesProducedStatsDataset(
-  inputDataset: VariantHandle,
-  tag: StringTensor,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalBytesProducedStatsDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(tag)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func experimentalCSVDataset<OutputTypes: TensorArrayProtocol>(
-  filenames: StringTensor,
-  compressionType: StringTensor,
-  bufferSize: Tensor<Int64>,
-  header: Tensor<Bool>,
-  fieldDelim: StringTensor,
-  useQuoteDelim: Tensor<Bool>,
-  naValue: StringTensor,
-  selectCols: Tensor<Int64>,
-  recordDefaults: OutputTypes,
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalCSVDataset")
-  op.setAttr("output_types", recordDefaults._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(filenames)
-  let _ = op.addInput(compressionType)
-  let _ = op.addInput(bufferSize)
-  let _ = op.addInput(header)
-  let _ = op.addInput(fieldDelim)
-  let _ = op.addInput(useQuoteDelim)
-  let _ = op.addInput(naValue)
-  let _ = op.addInput(selectCols)
-  let _ = op.addInputList(recordDefaults)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func experimentalChooseFastestDataset(
-  inputDatasets: [VariantHandle],
-  numExperiments: Int64,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalChooseFastestDataset")
-  op.setAttr("N", inputDatasets.count)
-  op.setAttr("num_experiments", numExperiments)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInputList(inputDatasets)
-  return op.execute(Int(1))
-}
-
-/// Returns the cardinality of `input_dataset`.
-///
-/// Returns the cardinality of `input_dataset`.
-///
-/// - Parameter input_dataset: A variant tensor representing the dataset to return cardinality for.
-///
-/// - Output cardinality: The cardinality of `input_dataset`. Named constants are used to represent
-///   infinite and unknown cardinality.
-@inlinable
-public static func experimentalDatasetCardinality(
-  inputDataset: VariantHandle
-) -> Tensor<Int64> {
-  let op = TFE_Op("ExperimentalDatasetCardinality")
-  let _ = op.addInput(inputDataset)
-  return op.execute(Int(1))
-}
-
-/// Writes the given dataset to the given file using the TFRecord format.
-///
-/// - Parameters:
-///   - input_dataset: A variant tensor representing the dataset to write.
-///   - filename: A scalar string tensor representing the filename to use.
-///   - compression_type: A scalar string tensor containing either (i) the empty string (no
-///     compression), (ii) "ZLIB", or (iii) "GZIP".
-@inlinable
-public static func experimentalDatasetToTFRecord(
-  inputDataset: VariantHandle,
-  filename: StringTensor,
-  compressionType: StringTensor
-) {
-  let op = TFE_Op("ExperimentalDatasetToTFRecord")
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(filename)
-  let _ = op.addInput(compressionType)
-  op.execute()
-}
-
-/// Creates a dataset that batches input elements into a SparseTensor.
-///
-/// - Parameters:
-///   - input_dataset: A handle to an input dataset. Must have a single component.
-///   - batch_size: A scalar representing the number of elements to accumulate in a
-///     batch.
-///   - row_shape: A vector representing the dense shape of each row in the produced
-///     SparseTensor. The shape may be partially specified, using `-1` to indicate
-///     that a particular dimension should use the maximum size of all batch elements.
-@inlinable
-public static func experimentalDenseToSparseBatchDataset(
-  inputDataset: VariantHandle,
-  batchSize: Tensor<Int64>,
-  rowShape: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalDenseToSparseBatchDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(batchSize)
-  let _ = op.addInput(rowShape)
-  return op.execute(Int(1))
-}
-
-/// A substitute for `InterleaveDataset` on a fixed list of `N` datasets.
-///
-/// - Parameters:
-///   - selector_input_dataset: A dataset of scalar `DT_INT64` elements that determines which of the
-///     `N` data inputs should produce the next output element.
-///   - data_input_datasets: `N` datasets with the same type that will be interleaved according to
-///     the values of `selector_input_dataset`.
-@inlinable
-public static func experimentalDirectedInterleaveDataset(
-  selectorInputDataset: VariantHandle,
-  dataInputDatasets: [VariantHandle],
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalDirectedInterleaveDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("N", dataInputDatasets.count)
-  let _ = op.addInput(selectorInputDataset)
-  let _ = op.addInputList(dataInputDatasets)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that computes a group-by on `input_dataset`.
-///
-/// Creates a dataset that computes a group-by on `input_dataset`.
-///
-/// - Parameters:
-///   - input_dataset: A variant tensor representing the input dataset.
-///   - key_func_other_arguments: A list of tensors, typically values that were captured when
-///     building a closure for `key_func`.
-///   - init_func_other_arguments: A list of tensors, typically values that were captured when
-///     building a closure for `init_func`.
-///   - reduce_func_other_arguments: A list of tensors, typically values that were captured when
-///     building a closure for `reduce_func`.
-///   - finalize_func_other_arguments: A list of tensors, typically values that were captured when
-///     building a closure for `finalize_func`.
-///
-/// - Attrs:
-///   - key_func: A function mapping an element of `input_dataset`, concatenated
-///     with `key_func_other_arguments` to a scalar value of type DT_INT64.
-///   - init_func: A function mapping a key of type DT_INT64, concatenated with
-///     `init_func_other_arguments` to the initial reducer state.
-///   - reduce_func: A function mapping the current reducer state and an element of `input_dataset`,
-///     concatenated with `reduce_func_other_arguments` to a new reducer state.
-///   - finalize_func: A function mapping the final reducer state to an output element.
-@inlinable
-public static func experimentalGroupByReducerDataset<
-    KeyfuncIn: TensorGroup,
-    KeyfuncOut: TensorGroup,
-    InitfuncIn: TensorGroup,
-    InitfuncOut: TensorGroup,
-    ReducefuncIn: TensorGroup,
-    ReducefuncOut: TensorGroup,
-    FinalizefuncIn: TensorGroup,
-    FinalizefuncOut: TensorGroup,
-    TkeyFuncOtherArguments: TensorArrayProtocol,
-    TinitFuncOtherArguments: TensorArrayProtocol,
-    TreduceFuncOtherArguments: TensorArrayProtocol,
-    TfinalizeFuncOtherArguments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  keyFuncOtherArguments: TkeyFuncOtherArguments,
-  initFuncOtherArguments: TinitFuncOtherArguments,
-  reduceFuncOtherArguments: TreduceFuncOtherArguments,
-  finalizeFuncOtherArguments: TfinalizeFuncOtherArguments,
-  keyFunc: (KeyfuncIn) -> KeyfuncOut,
-  initFunc: (InitfuncIn) -> InitfuncOut,
-  reduceFunc: (ReducefuncIn) -> ReducefuncOut,
-  finalizeFunc: (FinalizefuncIn) -> FinalizefuncOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalGroupByReducerDataset")
-  op.setAttr("key_func", keyFunc)
-  op.setAttr("init_func", initFunc)
-  op.setAttr("reduce_func", reduceFunc)
-  op.setAttr("finalize_func", finalizeFunc)
-  op.setAttr("Tkey_func_other_arguments", keyFuncOtherArguments._typeList)
-  op.setAttr("Tinit_func_other_arguments", initFuncOtherArguments._typeList)
-  op.setAttr("Treduce_func_other_arguments", reduceFuncOtherArguments._typeList)
-  op.setAttr("Tfinalize_func_other_arguments", finalizeFuncOtherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(keyFuncOtherArguments)
-  let _ = op.addInputList(initFuncOtherArguments)
-  let _ = op.addInputList(reduceFuncOtherArguments)
-  let _ = op.addInputList(finalizeFuncOtherArguments)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that computes a windowed group-by on `input_dataset`.
-///
-/// // TODO(mrry): Support non-int64 keys.
-///
-/// - Attr key_func: A function mapping an element of `input_dataset`, concatenated
-///   with `key_func_other_arguments` to a scalar value of type DT_INT64.
-@inlinable
-public static func experimentalGroupByWindowDataset<
-    KeyfuncIn: TensorGroup,
-    KeyfuncOut: TensorGroup,
-    ReducefuncIn: TensorGroup,
-    ReducefuncOut: TensorGroup,
-    WindowsizefuncIn: TensorGroup,
-    WindowsizefuncOut: TensorGroup,
-    TkeyFuncOtherArguments: TensorArrayProtocol,
-    TreduceFuncOtherArguments: TensorArrayProtocol,
-    TwindowSizeFuncOtherArguments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  keyFuncOtherArguments: TkeyFuncOtherArguments,
-  reduceFuncOtherArguments: TreduceFuncOtherArguments,
-  windowSizeFuncOtherArguments: TwindowSizeFuncOtherArguments,
-  keyFunc: (KeyfuncIn) -> KeyfuncOut,
-  reduceFunc: (ReducefuncIn) -> ReducefuncOut,
-  windowSizeFunc: (WindowsizefuncIn) -> WindowsizefuncOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalGroupByWindowDataset")
-  op.setAttr("key_func", keyFunc)
-  op.setAttr("reduce_func", reduceFunc)
-  op.setAttr("window_size_func", windowSizeFunc)
-  op.setAttr("Tkey_func_other_arguments", keyFuncOtherArguments._typeList)
-  op.setAttr("Treduce_func_other_arguments", reduceFuncOtherArguments._typeList)
-  op.setAttr("Twindow_size_func_other_arguments", windowSizeFuncOtherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(keyFuncOtherArguments)
-  let _ = op.addInputList(reduceFuncOtherArguments)
-  let _ = op.addInputList(windowSizeFuncOtherArguments)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func experimentalIdentityIndexedDataset(
-  size: Tensor<UInt64>
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalIdentityIndexedDataset")
-  let _ = op.addInput(size)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that contains the elements of `input_dataset` ignoring errors.
-@inlinable
-public static func experimentalIgnoreErrorsDataset(
-  inputDataset: VariantHandle,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalIgnoreErrorsDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func experimentalIndexedDatasetGet<OutputTypes: TensorGroup>(
-  materialized: ResourceHandle,
-  index: Tensor<UInt64>,
-  outputShapes: [TensorShape?]
-) -> OutputTypes {
-  let op = TFE_Op("ExperimentalIndexedDatasetGet")
-  op.setAttr("output_types", OutputTypes._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(materialized)
-  let _ = op.addInput(index)
-  return op.execute(Int(OutputTypes._typeList.count))
-}
-
-@inlinable
-public static func experimentalIndexedDatasetMaterialize(
-  dataset: VariantHandle,
-  materialized: ResourceHandle
-) {
-  let op = TFE_Op("ExperimentalIndexedDatasetMaterialize")
-  let _ = op.addInput(dataset)
-  let _ = op.addInput(materialized)
-  op.execute()
-}
-
-/// Returns the name of the device on which `resource` has been placed.
-@inlinable
-public static func experimentalIteratorGetDevice(
-  resource: ResourceHandle
-) -> StringTensor {
-  let op = TFE_Op("ExperimentalIteratorGetDevice")
-  let _ = op.addInput(resource)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func experimentalLMDBDataset(
-  filenames: StringTensor,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalLMDBDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(filenames)
-  return op.execute(Int(1))
-}
-
-/// Records the latency of producing `input_dataset` elements in a StatsAggregator.
-@inlinable
-public static func experimentalLatencyStatsDataset(
-  inputDataset: VariantHandle,
-  tag: StringTensor,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalLatencyStatsDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(tag)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that fuses mapping with batching.
-///
-/// Creates a dataset that applies `f` to the outputs of `input_dataset` and then
-/// batches `batch_size` of them.
-///
-/// Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
-/// to `batch_size * num_parallel_batches` copies of `f` in parallel.
-///
-/// - Parameters:
-///   - input_dataset: A variant tensor representing the input dataset.
-///   - other_arguments: A list of tensors, typically values that were captured when building a closure
-///     for `f`.
-///   - batch_size: A scalar representing the number of elements to accumulate in a
-///     batch. It determines the number of concurrent invocations of `f` that process
-///     elements from `input_dataset` in parallel.
-///   - num_parallel_calls: A scalar representing the maximum number of parallel invocations of the `map_fn`
-///     function. Applying the `map_fn` on consecutive input elements in parallel has
-///     the potential to improve input pipeline throughput.
-///   - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
-///     is smaller than desired.
-///
-/// - Attr f: A function to apply to the outputs of `input_dataset`.
-@inlinable
-public static func experimentalMapAndBatchDataset<
-    FIn: TensorGroup,
-    FOut: TensorGroup,
-    Targuments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  otherArguments: Targuments,
-  batchSize: Tensor<Int64>,
-  numParallelCalls: Tensor<Int64>,
-  dropRemainder: Tensor<Bool>,
-  f: (FIn) -> FOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?],
-  preserveCardinality: Bool = false
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalMapAndBatchDataset")
-  op.setAttr("f", f)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("preserve_cardinality", preserveCardinality)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(otherArguments)
-  let _ = op.addInput(batchSize)
-  let _ = op.addInput(numParallelCalls)
-  let _ = op.addInput(dropRemainder)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
-@inlinable
-public static func experimentalMapDataset<
-    FIn: TensorGroup,
-    FOut: TensorGroup,
-    Targuments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  otherArguments: Targuments,
-  f: (FIn) -> FOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?],
-  useInterOpParallelism: Bool = true,
-  preserveCardinality: Bool = false
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalMapDataset")
-  op.setAttr("f", f)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("use_inter_op_parallelism", useInterOpParallelism)
-  op.setAttr("preserve_cardinality", preserveCardinality)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(otherArguments)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func experimentalMatchingFilesDataset(
-  patterns: StringTensor
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalMatchingFilesDataset")
-  let _ = op.addInput(patterns)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func experimentalMaterializedIndexDatasetHandle(
-  container: String,
-  sharedName: String,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> ResourceHandle {
-  let op = TFE_Op("ExperimentalMaterializedIndexDatasetHandle")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that overrides the maximum intra-op parallelism.
-///
-/// - Parameter max_intra_op_parallelism: Identifies the maximum intra-op parallelism to use.
-@inlinable
-public static func experimentalMaxIntraOpParallelismDataset(
-  inputDataset: VariantHandle,
-  maxIntraOpParallelism: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalMaxIntraOpParallelismDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(maxIntraOpParallelism)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func experimentalNonSerializableDataset(
-  inputDataset: VariantHandle,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalNonSerializableDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that fuses mapping with batching.
-///
-/// Creates a dataset that applies `f` to the outputs of `input_dataset` and then
-/// batches `batch_size` of them.
-///
-/// Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
-/// to `batch_size * num_parallel_batches` copies of `f` in parallel.
-///
-/// Unlike "MapAndBatchDatasetV2", this dataset uses a NUMA-aware thread scheduling
-/// policy. Because it uses the single-threaded executor, it only supports the
-/// function-based control flow ops.
-///
-/// - Parameters:
-///   - input_dataset: A variant tensor representing the input dataset.
-///   - other_arguments: A list of tensors, typically values that were captured when building a closure
-///     for `f`.
-///   - batch_size: A scalar representing the number of elements to accumulate in a
-///     batch. It determines the number of concurrent invocations of `f` that process
-///     elements from `input_dataset` in parallel.
-///   - num_parallel_calls: A scalar representing the maximum number of parallel invocations of the `map_fn`
-///     function. Applying the `map_fn` on consecutive input elements in parallel has
-///     the potential to improve input pipeline throughput.
-///   - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
-///     is smaller than desired.
-///
-/// - Attr f: A function to apply to the outputs of `input_dataset`.
-@inlinable
-public static func experimentalNumaMapAndBatchDataset<
-    FIn: TensorGroup,
-    FOut: TensorGroup,
-    Targuments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  otherArguments: Targuments,
-  batchSize: Tensor<Int64>,
-  numParallelCalls: Tensor<Int64>,
-  dropRemainder: Tensor<Bool>,
-  f: (FIn) -> FOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?],
-  preserveCardinality: Bool = false
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalNumaMapAndBatchDataset")
-  op.setAttr("f", f)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("preserve_cardinality", preserveCardinality)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(otherArguments)
-  let _ = op.addInput(batchSize)
-  let _ = op.addInput(numParallelCalls)
-  let _ = op.addInput(dropRemainder)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
-///
-/// The resulting dataset is similar to the `InterleaveDataset`, with the exception
-/// that if retrieving the next value from a dataset would cause the requester to
-/// block, it will skip that input dataset. This dataset is especially useful
-/// when loading data from a variable-latency datastores (e.g. HDFS, GCS), as it
-/// allows the training step to proceed so long as some data is available.
-///
-/// !! WARNING !! This dataset is not deterministic!
-///
-/// - Attr f: A function mapping elements of `input_dataset`, concatenated with
-///   `other_arguments`, to a Dataset variant that contains elements matching
-///   `output_types` and `output_shapes`.
-@inlinable
-public static func experimentalParallelInterleaveDataset<
-    FIn: TensorGroup,
-    FOut: TensorGroup,
-    Targuments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  otherArguments: Targuments,
-  cycleLength: Tensor<Int64>,
-  blockLength: Tensor<Int64>,
-  sloppy: Tensor<Bool>,
-  bufferOutputElements: Tensor<Int64>,
-  prefetchInputElements: Tensor<Int64>,
-  f: (FIn) -> FOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalParallelInterleaveDataset")
-  op.setAttr("f", f)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(otherArguments)
-  let _ = op.addInput(cycleLength)
-  let _ = op.addInput(blockLength)
-  let _ = op.addInput(sloppy)
-  let _ = op.addInput(bufferOutputElements)
-  let _ = op.addInput(prefetchInputElements)
-  return op.execute(Int(1))
-}
-
-/// Transforms `input_dataset` containing `Example` protos as vectors of DT_STRING into a dataset of `Tensor` or `SparseTensor` objects representing the parsed features.
-///
-/// - Parameter dense_defaults: A dict mapping string keys to `Tensor`s.
-///   The keys of the dict must match the dense_keys of the feature.
-///
-/// - Attrs:
-///   - sparse_keys: A list of string keys in the examples features.
-///     The results for these keys will be returned as `SparseTensor` objects.
-///   - dense_keys: A list of Ndense string Tensors (scalars).
-///     The keys expected in the Examples features associated with dense values.
-///   - sparse_types: A list of `DTypes` of the same length as `sparse_keys`.
-///     Only `tf.float32` (`FloatList`), `tf.int64` (`Int64List`),
-///     and `tf.string` (`BytesList`) are supported.
-///   - Tdense: A list of DTypes of the same length as `dense_keys`.
-///     Only `tf.float32` (`FloatList`), `tf.int64` (`Int64List`),
-///     and `tf.string` (`BytesList`) are supported.
-///
-///   - dense_shapes: List of tuples with the same length as `dense_keys`.
-///     The shape of the data for each dense feature referenced by `dense_keys`.
-///     Required for any input tensors identified by `dense_keys`.  Must be
-///     either fully defined, or may contain an unknown first dimension.
-///     An unknown first dimension means the feature is treated as having
-///     a variable number of blocks, and the output shape along this dimension
-///     is considered unknown at graph build time.  Padding is applied for
-///     minibatch elements smaller than the maximum number of blocks for the
-///     given feature along this dimension.
-///   - output_types: The type list for the return values.
-///   - output_shapes: The list of shapes being produced.
-@inlinable
-public static func experimentalParseExampleDataset<Tdense: TensorArrayProtocol>(
-  inputDataset: VariantHandle,
-  numParallelCalls: Tensor<Int64>,
-  denseDefaults: Tdense,
-  sparseKeys: [String],
-  denseKeys: [String],
-  sparseTypes: [TensorDataType],
-  denseShapes: [TensorShape?],
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?],
-  sloppy: Bool = false
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalParseExampleDataset")
-  op.setAttr("sparse_keys", sparseKeys)
-  op.setAttr("dense_keys", denseKeys)
-  op.setAttr("sparse_types", sparseTypes)
-  op.setAttr("Tdense", denseDefaults._typeList)
-  op.setAttr("dense_shapes", denseShapes)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("sloppy", sloppy)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(numParallelCalls)
-  let _ = op.addInputList(denseDefaults)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that uses a custom thread pool to compute `input_dataset`.
-///
-/// - Parameter num_threads: Identifies the number of threads to use for the private threadpool.
-@inlinable
-public static func experimentalPrivateThreadPoolDataset(
-  inputDataset: VariantHandle,
-  numThreads: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalPrivateThreadPoolDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(numThreads)
-  return op.execute(Int(1))
-}
-
-/// Creates a Dataset that returns pseudorandom numbers.
-///
-/// - Parameters:
-///   - seed: A scalar seed for the random number generator. If either seed or
-///     seed2 is set to be non-zero, the random number generator is seeded
-///     by the given seed.  Otherwise, a random seed is used.
-///   - seed2: A second scalar seed to avoid seed collision.
-@inlinable
-public static func experimentalRandomDataset(
-  seed: Tensor<Int64>,
-  seed2: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalRandomDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(seed)
-  let _ = op.addInput(seed2)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that changes the batch size.
-///
-/// Creates a dataset that changes the batch size of the dataset to current batch
-/// size // num_workers.
-///
-/// - Parameters:
-///   - input_dataset: A variant tensor representing the input dataset.
-///   - num_workers: A scalar representing the number of workers to distribute this batch across. As
-///     a result of this transformation the current batch size would end up being
-///     divided  by this parameter.
-@inlinable
-public static func experimentalRebatchDataset(
-  inputDataset: VariantHandle,
-  numWorkers: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalRebatchDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(numWorkers)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset successively reduces `f` over the elements of `input_dataset`.
-@inlinable
-public static func experimentalScanDataset<
-    FIn: TensorGroup,
-    FOut: TensorGroup,
-    Tstate: TensorArrayProtocol,
-    Targuments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  initialState: Tstate,
-  otherArguments: Targuments,
-  f: (FIn) -> FOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?],
-  preserveCardinality: Bool = false
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalScanDataset")
-  op.setAttr("f", f)
-  op.setAttr("Tstate", initialState._typeList)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("preserve_cardinality", preserveCardinality)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(initialState)
-  let _ = op.addInputList(otherArguments)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func experimentalSetStatsAggregatorDataset(
-  inputDataset: VariantHandle,
-  statsAggregator: ResourceHandle,
-  tag: StringTensor,
-  counterPrefix: StringTensor,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalSetStatsAggregatorDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(statsAggregator)
-  let _ = op.addInput(tag)
-  let _ = op.addInput(counterPrefix)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func experimentalSleepDataset(
-  inputDataset: VariantHandle,
-  sleepMicroseconds: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalSleepDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(sleepMicroseconds)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that passes a sliding window over `input_dataset`.
-///
-/// - Parameters:
-///   - window_size: A scalar representing the number of elements in the
-///     sliding window.
-///   - window_shift: A scalar representing the steps moving the sliding window
-///     forward in one iteration. It must be positive.
-///   - window_stride: A scalar representing the stride of the input elements of the sliding window.
-///     It must be positive.
-@inlinable
-public static func experimentalSlidingWindowDataset(
-  inputDataset: VariantHandle,
-  windowSize: Tensor<Int64>,
-  windowShift: Tensor<Int64>,
-  windowStride: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalSlidingWindowDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(windowSize)
-  let _ = op.addInput(windowShift)
-  let _ = op.addInput(windowStride)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that executes a SQL query and emits rows of the result set.
-///
-/// - Parameters:
-///   - driver_name: The database type. Currently, the only supported type is 'sqlite'.
-///   - data_source_name: A connection string to connect to the database.
-///   - query: A SQL query to execute.
-@inlinable
-public static func experimentalSqlDataset(
-  driverName: StringTensor,
-  dataSourceName: StringTensor,
-  query: StringTensor,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalSqlDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(driverName)
-  let _ = op.addInput(dataSourceName)
-  let _ = op.addInput(query)
-  return op.execute(Int(1))
-}
-
-/// Creates a statistics manager resource.
-@inlinable
-public static func experimentalStatsAggregatorHandle(
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("ExperimentalStatsAggregatorHandle")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Produces a summary of any statistics recorded by the given statistics manager.
-@inlinable
-public static func experimentalStatsAggregatorSummary(
-  iterator: ResourceHandle
-) -> StringTensor {
-  let op = TFE_Op("ExperimentalStatsAggregatorSummary")
-  let _ = op.addInput(iterator)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that stops iteration when predicate` is false.
-///
-/// The `predicate` function must return a scalar boolean and accept the
-/// following arguments:
-///
-/// * One tensor for each component of an element of `input_dataset`.
-/// * One tensor for each value in `other_arguments`.
-///
-/// - Parameter other_arguments: A list of tensors, typically values that were captured when
-///   building a closure for `predicate`.
-///
-/// - Attr predicate: A function returning a scalar boolean.
-@inlinable
-public static func experimentalTakeWhileDataset<
-    PredicateIn: TensorGroup,
-    PredicateOut: TensorGroup,
-    Targuments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  otherArguments: Targuments,
-  predicate: (PredicateIn) -> PredicateOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalTakeWhileDataset")
-  op.setAttr("predicate", predicate)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(otherArguments)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that uses a custom thread pool to compute `input_dataset`.
-///
-/// - Parameter thread_pool: A resource produced by the ThreadPoolHandle op.
-@inlinable
-public static func experimentalThreadPoolDataset(
-  inputDataset: VariantHandle,
-  threadPool: ResourceHandle,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalThreadPoolDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(threadPool)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that uses a custom thread pool to compute `input_dataset`.
-///
-/// - Attrs:
-///   - num_threads: The number of threads in the thread pool.
-///   - max_intra_op_parallelism: The maximum degree of parallelism to use within operations that execute on this
-///     threadpool.
-///   - display_name: A human-readable name for the threads that may be visible in some
-///     visualizations.
-///     threadpool.
-///
-/// - Output handle: A resource that can be consumed by one or more ExperimentalThreadPoolDataset
-///   ops.
-@inlinable
-public static func experimentalThreadPoolHandle(
-  numThreads: Int64,
-  maxIntraOpParallelism: Int64 = 1,
-  displayName: String,
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("ExperimentalThreadPoolHandle")
-  op.setAttr("num_threads", numThreads)
-  op.setAttr("max_intra_op_parallelism", maxIntraOpParallelism)
-  op.setAttr("display_name", displayName)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// A dataset that splits the elements of its input into multiple elements.
-@inlinable
-public static func experimentalUnbatchDataset(
-  inputDataset: VariantHandle,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalUnbatchDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that contains the unique elements of `input_dataset`.
-@inlinable
-public static func experimentalUniqueDataset(
-  inputDataset: VariantHandle,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ExperimentalUniqueDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  return op.execute(Int(1))
-}
-
-/// Computes exponential of x - 1 element-wise.
-///
-/// I.e., \\(y = (\exp x) - 1\\).
-@inlinable
-public static func expm1<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Expm1")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Extracts a glimpse from the input tensor.
-///
-/// Returns a set of windows called glimpses extracted at location
-/// `offsets` from the input tensor. If the windows only partially
-/// overlaps the inputs, the non overlapping areas will be filled with
-/// random noise.
-///
-/// The result is a 4-D tensor of shape `[batch_size, glimpse_height,
-/// glimpse_width, channels]`. The channels and batch dimensions are the
-/// same as that of the input tensor. The height and width of the output
-/// windows are specified in the `size` parameter.
-///
-/// The argument `normalized` and `centered` controls how the windows are built:
-///
-/// * If the coordinates are normalized but not centered, 0.0 and 1.0
-///   correspond to the minimum and maximum of each height and width
-///   dimension.
-/// * If the coordinates are both normalized and centered, they range from
-///   -1.0 to 1.0. The coordinates (-1.0, -1.0) correspond to the upper
-///   left corner, the lower right corner is located at (1.0, 1.0) and the
-///   center is at (0, 0).
-/// * If the coordinates are not normalized they are interpreted as
-///   numbers of pixels.
-///
-/// - Parameters:
-///   - input: A 4-D float tensor of shape `[batch_size, height, width, channels]`.
-///   - size: A 1-D tensor of 2 elements containing the size of the glimpses
-///     to extract.  The glimpse height must be specified first, following
-///     by the glimpse width.
-///   - offsets: A 2-D integer tensor of shape `[batch_size, 2]` containing
-///     the y, x locations of the center of each window.
-///
-/// - Attrs:
-///   - centered: indicates if the offset coordinates are centered relative to
-///     the image, in which case the (0, 0) offset is relative to the center
-///     of the input images. If false, the (0,0) offset corresponds to the
-///     upper left corner of the input images.
-///   - normalized: indicates if the offset coordinates are normalized.
-///   - uniform_noise: indicates if the noise should be generated using a
-///     uniform distribution or a Gaussian distribution.
-///   - noise: indicates if the noise should `uniform`, `gaussian`, or
-///     `zero`. The default is `uniform` which means the the noise type
-///     will be decided by `uniform_noise`.
-///
-/// - Output glimpse: A tensor representing the glimpses `[batch_size,
-///   glimpse_height, glimpse_width, channels]`.
-@inlinable
-public static func extractGlimpse(
-  _ input: Tensor<Float>,
-  size: Tensor<Int32>,
-  offsets: Tensor<Float>,
-  centered: Bool = true,
-  normalized: Bool = true,
-  uniformNoise: Bool = true,
-  noise: String = "uniform"
-) -> Tensor<Float> {
-  let op = TFE_Op("ExtractGlimpse")
-  op.setAttr("centered", centered)
-  op.setAttr("normalized", normalized)
-  op.setAttr("uniform_noise", uniformNoise)
-  op.setAttr("noise", noise)
-  let _ = op.addInput(input)
-  let _ = op.addInput(size)
-  let _ = op.addInput(offsets)
-  return op.execute(Int(1))
-}
-
-/// Extract `patches` from `images` and put them in the "depth" output dimension.
-///
-/// - Parameter images: 4-D Tensor with shape `[batch, in_rows, in_cols, depth]`.
-///
-/// - Attrs:
-///   - ksizes: The size of the sliding window for each dimension of `images`.
-///   - strides: 1-D of length 4. How far the centers of two consecutive patches are in
-///     the images. Must be: `[1, stride_rows, stride_cols, 1]`.
-///   - rates: 1-D of length 4. Must be: `[1, rate_rows, rate_cols, 1]`. This is the
-///     input stride, specifying how far two consecutive patch samples are in the
-///     input. Equivalent to extracting patches with
-///     `patch_sizes_eff = patch_sizes + (patch_sizes - 1) * (rates - 1)`, followed by
-///     subsampling them spatially by a factor of `rates`. This is equivalent to
-///     `rate` in dilated (a.k.a. Atrous) convolutions.
-///   - padding: The type of padding algorithm to use.
-///
-///     We specify the size-related attributes as:
-///
-///     ```python
-///           ksizes = [1, ksize_rows, ksize_cols, 1]
-///           strides = [1, strides_rows, strides_cols, 1]
-///           rates = [1, rates_rows, rates_cols, 1]
-///     ```
-///
-/// - Output patches: 4-D Tensor with shape `[batch, out_rows, out_cols, ksize_rows *
-///   ksize_cols * depth]` containing image patches with size
-///   `ksize_rows x ksize_cols x depth` vectorized in the "depth" dimension. Note
-///   `out_rows` and `out_cols` are the dimensions of the output patches.
-@inlinable
-public static func extractImagePatches<T: Numeric & TensorFlowScalar>(
-  images: Tensor<T>,
-  ksizes: [Int32],
-  strides: [Int32],
-  rates: [Int32],
-  padding: Padding
-) -> Tensor<T> {
-  let op = TFE_Op("ExtractImagePatches")
-  op.setAttr("ksizes", ksizes)
-  op.setAttr("strides", strides)
-  op.setAttr("rates", rates)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("padding", padding.cName)
-  let _ = op.addInput(images)
-  return op.execute(Int(1))
-}
-
-/// Extract the shape information of a JPEG-encoded image.
-///
-/// This op only parses the image header, so it is much faster than DecodeJpeg.
-///
-/// - Parameter contents: 0-D. The JPEG-encoded image.
-///
-/// - Attr output_type: (Optional) The output type of the operation (int32 or int64).
-///   Defaults to int32.
-///
-/// - Output image_shape: 1-D. The image shape with format [height, width, channels].
-@inlinable
-public static func extractJpegShape<OutputType: BinaryInteger & TensorFlowScalar>(
-  contents: StringTensor
-) -> Tensor<OutputType> {
-  let op = TFE_Op("ExtractJpegShape")
-  op.setAttr("output_type", OutputType.tensorFlowDataType)
-  let _ = op.addInput(contents)
-  return op.execute(Int(1))
-}
-
-/// Extract `patches` from `input` and put them in the "depth" output dimension. 3D extension of `extract_image_patches`.
-///
-/// - Parameter input: 5-D Tensor with shape `[batch, in_planes, in_rows, in_cols, depth]`.
-///
-/// - Attrs:
-///   - ksizes: The size of the sliding window for each dimension of `input`.
-///   - strides: 1-D of length 5. How far the centers of two consecutive patches are in
-///     `input`. Must be: `[1, stride_planes, stride_rows, stride_cols, 1]`.
-///   - padding: The type of padding algorithm to use.
-///
-///     We specify the size-related attributes as:
-///
-///     ```python
-///           ksizes = [1, ksize_planes, ksize_rows, ksize_cols, 1]
-///           strides = [1, stride_planes, strides_rows, strides_cols, 1]
-///     ```
-///
-/// - Output patches: 5-D Tensor with shape `[batch, out_planes, out_rows, out_cols,
-///   ksize_planes * ksize_rows * ksize_cols * depth]` containing patches
-///   with size `ksize_planes x ksize_rows x ksize_cols x depth` vectorized
-///   in the "depth" dimension. Note `out_planes`, `out_rows` and `out_cols`
-///   are the dimensions of the output patches.
-@inlinable
-public static func extractVolumePatches<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  ksizes: [Int32],
-  strides: [Int32],
-  padding: Padding
-) -> Tensor<T> {
-  let op = TFE_Op("ExtractVolumePatches")
-  op.setAttr("ksizes", ksizes)
-  op.setAttr("strides", strides)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("padding", padding.cName)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Fast Fourier transform.
-///
-/// Computes the 1-dimensional discrete Fourier transform over the inner-most
-/// dimension of `input`.
-///
-/// - Parameter input: A complex tensor.
-///
-/// - Output output: A complex tensor of the same shape as `input`. The inner-most
-///     dimension of `input` is replaced with its 1D Fourier transform.
-///
-///   @compatibility(numpy)
-///   Equivalent to np.fft.fft
-///   @end_compatibility
-@inlinable
-public static func fFT<Tcomplex: TensorFlowScalar>(
-  _ input: Tensor<Tcomplex>
-) -> Tensor<Tcomplex> {
-  let op = TFE_Op("FFT")
-  op.setAttr("Tcomplex", Tcomplex.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// 2D fast Fourier transform.
-///
-/// Computes the 2-dimensional discrete Fourier transform over the inner-most
-/// 2 dimensions of `input`.
-///
-/// - Parameter input: A complex tensor.
-///
-/// - Output output: A complex tensor of the same shape as `input`. The inner-most 2
-///     dimensions of `input` are replaced with their 2D Fourier transform.
-///
-///   @compatibility(numpy)
-///   Equivalent to np.fft.fft2
-///   @end_compatibility
-@inlinable
-public static func fFT2D<Tcomplex: TensorFlowScalar>(
-  _ input: Tensor<Tcomplex>
-) -> Tensor<Tcomplex> {
-  let op = TFE_Op("FFT2D")
-  op.setAttr("Tcomplex", Tcomplex.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// 3D fast Fourier transform.
-///
-/// Computes the 3-dimensional discrete Fourier transform over the inner-most 3
-/// dimensions of `input`.
-///
-/// - Parameter input: A complex64 tensor.
-///
-/// - Output output: A complex64 tensor of the same shape as `input`. The inner-most 3
-///     dimensions of `input` are replaced with their 3D Fourier transform.
-///
-///   @compatibility(numpy)
-///   Equivalent to np.fft.fftn with 3 dimensions.
-///   @end_compatibility
-@inlinable
-public static func fFT3D<Tcomplex: TensorFlowScalar>(
-  _ input: Tensor<Tcomplex>
-) -> Tensor<Tcomplex> {
-  let op = TFE_Op("FFT3D")
-  op.setAttr("Tcomplex", Tcomplex.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// A queue that produces elements in first-in first-out order.
-///
-/// - Attrs:
-///   - component_types: The type of each component in a value.
-///   - shapes: The shape of each component in a value. The length of this attr must
-///     be either 0 or the same as the length of component_types. If the length of
-///     this attr is 0, the shapes of queue elements are not constrained, and
-///     only one element may be dequeued at a time.
-///   - capacity: The upper bound on the number of elements in this queue.
-///     Negative numbers mean no limit.
-///   - container: If non-empty, this queue is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this queue will be shared under the given name
-///     across multiple sessions.
-///
-/// - Output handle: The handle to the queue.
-@inlinable
-public static func fIFOQueueV2(
-  componentTypes: [TensorDataType],
-  shapes: [TensorShape?],
-  capacity: Int64 = -1,
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("FIFOQueueV2")
-  op.setAttr("component_types", componentTypes)
-  op.setAttr("shapes", shapes)
-  op.setAttr("capacity", capacity)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Output a fact about factorials.
-@inlinable
-public static func fact(
-) -> StringTensor {
-  let op = TFE_Op("Fact")
-  
-  return op.execute(Int(1))
-}
-
-///   This op is used as a placeholder in If branch functions. It doesn't provide a
-///   valid output when run, so must either be removed (e.g. replaced with a
-///   function input) or guaranteed not to be used (e.g. if mirroring an
-///   intermediate output needed for the gradient computation of the other branch).
-///
-/// - Attrs:
-///   - dtype: The type of the output.
-///   - shape:     The purported shape of the output. This is only used for shape inference;
-///         the output will not necessarily have this shape. Can be a partial shape.
-///
-/// - Output output:     \"Fake\" output value. This should not be consumed by another op.
-@inlinable
-public static func fakeParam<Dtype: TensorFlowScalar>(
-  shape: TensorShape?
-) -> Tensor<Dtype> {
-  let op = TFE_Op("FakeParam")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape", shape)
-  return op.execute(Int(1))
-}
-
-/// Fake-quantize the 'inputs' tensor, type float to 'outputs' tensor of same type.
-///
-/// Attributes `[min; max]` define the clamping range for the `inputs` data.
-/// `inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
-/// when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
-/// then de-quantized and output as floats in `[min; max]` interval.
-/// `num_bits` is the bitwidth of the quantization; between 2 and 16, inclusive.
-///
-/// Before quantization, `min` and `max` values are adjusted with the following
-/// logic.
-/// It is suggested to have `min <= 0 <= max`. If `0` is not in the range of values,
-/// the behavior can be unexpected:
-/// If `0 < min < max`: `min_adj = 0` and `max_adj = max - min`.
-/// If `min < max < 0`: `min_adj = min - max` and `max_adj = 0`.
-/// If `min <= 0 <= max`: `scale = (max - min) / (2^num_bits - 1) `,
-/// `min_adj = scale * round(min / scale)` and `max_adj = max + min_adj - min`.
-///
-/// Quantization is called fake since the output is still in floating point.
-@inlinable
-public static func fakeQuantWithMinMaxArgs(
-  inputs: Tensor<Float>,
-  min: Double = -6,
-  max: Double = 6,
-  numBits: Int64 = 8,
-  narrowRange: Bool = false
-) -> Tensor<Float> {
-  let op = TFE_Op("FakeQuantWithMinMaxArgs")
-  op.setAttr("min", min)
-  op.setAttr("max", max)
-  op.setAttr("num_bits", numBits)
-  op.setAttr("narrow_range", narrowRange)
-  let _ = op.addInput(inputs)
-  return op.execute(Int(1))
-}
-
-/// Compute gradients for a FakeQuantWithMinMaxArgs operation.
-///
-/// - Parameters:
-///   - gradients: Backpropagated gradients above the FakeQuantWithMinMaxArgs operation.
-///   - inputs: Values passed as inputs to the FakeQuantWithMinMaxArgs operation.
-///
-/// - Output backprops: Backpropagated gradients below the FakeQuantWithMinMaxArgs operation:
-///   `gradients * (inputs >= min && inputs <= max)`.
-@inlinable
-public static func fakeQuantWithMinMaxArgsGradient(
-  gradients: Tensor<Float>,
-  inputs: Tensor<Float>,
-  min: Double = -6,
-  max: Double = 6,
-  numBits: Int64 = 8,
-  narrowRange: Bool = false
-) -> Tensor<Float> {
-  let op = TFE_Op("FakeQuantWithMinMaxArgsGradient")
-  op.setAttr("min", min)
-  op.setAttr("max", max)
-  op.setAttr("num_bits", numBits)
-  op.setAttr("narrow_range", narrowRange)
-  let _ = op.addInput(gradients)
-  let _ = op.addInput(inputs)
-  return op.execute(Int(1))
-}
-
-/// Fake-quantize the 'inputs' tensor of type float via global float scalars `min`
-///
-/// and `max` to 'outputs' tensor of same shape as `inputs`.
-///
-/// `[min; max]` define the clamping range for the `inputs` data.
-/// `inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
-/// when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
-/// then de-quantized and output as floats in `[min; max]` interval.
-/// `num_bits` is the bitwidth of the quantization; between 2 and 16, inclusive.
-///
-/// Before quantization, `min` and `max` values are adjusted with the following
-/// logic.
-/// It is suggested to have `min <= 0 <= max`. If `0` is not in the range of values,
-/// the behavior can be unexpected:
-/// If `0 < min < max`: `min_adj = 0` and `max_adj = max - min`.
-/// If `min < max < 0`: `min_adj = min - max` and `max_adj = 0`.
-/// If `min <= 0 <= max`: `scale = (max - min) / (2^num_bits - 1) `,
-/// `min_adj = scale * round(min / scale)` and `max_adj = max + min_adj - min`.
-///
-/// This operation has a gradient and thus allows for training `min` and `max`
-/// values.
-@inlinable
-public static func fakeQuantWithMinMaxVars(
-  inputs: Tensor<Float>,
-  min: Tensor<Float>,
-  max: Tensor<Float>,
-  numBits: Int64 = 8,
-  narrowRange: Bool = false
-) -> Tensor<Float> {
-  let op = TFE_Op("FakeQuantWithMinMaxVars")
-  op.setAttr("num_bits", numBits)
-  op.setAttr("narrow_range", narrowRange)
-  let _ = op.addInput(inputs)
-  let _ = op.addInput(min)
-  let _ = op.addInput(max)
-  return op.execute(Int(1))
-}
-
-/// Compute gradients for a FakeQuantWithMinMaxVars operation.
-///
-/// - Parameters:
-///   - gradients: Backpropagated gradients above the FakeQuantWithMinMaxVars operation.
-///   - inputs: Values passed as inputs to the FakeQuantWithMinMaxVars operation.
-///     min, max: Quantization interval, scalar floats.
-///
-/// - Attrs:
-///   - num_bits: The bitwidth of the quantization; between 2 and 8, inclusive.
-///   - narrow_range: Whether to quantize into 2^num_bits - 1 distinct values.
-///
-/// - Outputs:
-///   - backprops_wrt_input: Backpropagated gradients w.r.t. inputs:
-///     `gradients * (inputs >= min && inputs <= max)`.
-///   - backprop_wrt_min: Backpropagated gradients w.r.t. min parameter:
-///     `sum(gradients * (inputs < min))`.
-///   - backprop_wrt_max: Backpropagated gradients w.r.t. max parameter:
-///     `sum(gradients * (inputs > max))`.
-@inlinable
-public static func fakeQuantWithMinMaxVarsGradient(
-  gradients: Tensor<Float>,
-  inputs: Tensor<Float>,
-  min: Tensor<Float>,
-  max: Tensor<Float>,
-  numBits: Int64 = 8,
-  narrowRange: Bool = false
-) -> (backpropsWrtInput: Tensor<Float>, backpropWrtMin: Tensor<Float>, backpropWrtMax: Tensor<Float>) {
-  let op = TFE_Op("FakeQuantWithMinMaxVarsGradient")
-  op.setAttr("num_bits", numBits)
-  op.setAttr("narrow_range", narrowRange)
-  let _ = op.addInput(gradients)
-  let _ = op.addInput(inputs)
-  let _ = op.addInput(min)
-  let _ = op.addInput(max)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Fake-quantize the 'inputs' tensor of type float and one of the shapes: `[d]`,
-///
-/// `[b, d]` `[b, h, w, d]` via per-channel floats `min` and `max` of shape `[d]`
-/// to 'outputs' tensor of same shape as `inputs`.
-///
-/// `[min; max]` define the clamping range for the `inputs` data.
-/// `inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
-/// when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
-/// then de-quantized and output as floats in `[min; max]` interval.
-/// `num_bits` is the bitwidth of the quantization; between 2 and 16, inclusive.
-///
-/// Before quantization, `min` and `max` values are adjusted with the following
-/// logic.
-/// It is suggested to have `min <= 0 <= max`. If `0` is not in the range of values,
-/// the behavior can be unexpected:
-/// If `0 < min < max`: `min_adj = 0` and `max_adj = max - min`.
-/// If `min < max < 0`: `min_adj = min - max` and `max_adj = 0`.
-/// If `min <= 0 <= max`: `scale = (max - min) / (2^num_bits - 1) `,
-/// `min_adj = scale * round(min / scale)` and `max_adj = max + min_adj - min`.
-///
-/// This operation has a gradient and thus allows for training `min` and `max`
-/// values.
-@inlinable
-public static func fakeQuantWithMinMaxVarsPerChannel(
-  inputs: Tensor<Float>,
-  min: Tensor<Float>,
-  max: Tensor<Float>,
-  numBits: Int64 = 8,
-  narrowRange: Bool = false
-) -> Tensor<Float> {
-  let op = TFE_Op("FakeQuantWithMinMaxVarsPerChannel")
-  op.setAttr("num_bits", numBits)
-  op.setAttr("narrow_range", narrowRange)
-  let _ = op.addInput(inputs)
-  let _ = op.addInput(min)
-  let _ = op.addInput(max)
-  return op.execute(Int(1))
-}
-
-/// Compute gradients for a FakeQuantWithMinMaxVarsPerChannel operation.
-///
-/// - Parameters:
-///   - gradients: Backpropagated gradients above the FakeQuantWithMinMaxVars operation,
-///     shape one of: `[d]`, `[b, d]`,  `[b, h, w, d]`.
-///   - inputs: Values passed as inputs to the FakeQuantWithMinMaxVars operation, shape
-///       same as `gradients`.
-///     min, max: Quantization interval, floats of shape `[d]`.
-///
-/// - Attrs:
-///   - num_bits: The bitwidth of the quantization; between 2 and 16, inclusive.
-///   - narrow_range: Whether to quantize into 2^num_bits - 1 distinct values.
-///
-/// - Outputs:
-///   - backprops_wrt_input: Backpropagated gradients w.r.t. inputs, shape same as
-///     `inputs`:
-///       `gradients * (inputs >= min && inputs <= max)`.
-///   - backprop_wrt_min: Backpropagated gradients w.r.t. min parameter, shape `[d]`:
-///     `sum_per_d(gradients * (inputs < min))`.
-///   - backprop_wrt_max: Backpropagated gradients w.r.t. max parameter, shape `[d]`:
-///     `sum_per_d(gradients * (inputs > max))`.
-@inlinable
-public static func fakeQuantWithMinMaxVarsPerChannelGradient(
-  gradients: Tensor<Float>,
-  inputs: Tensor<Float>,
-  min: Tensor<Float>,
-  max: Tensor<Float>,
-  numBits: Int64 = 8,
-  narrowRange: Bool = false
-) -> (backpropsWrtInput: Tensor<Float>, backpropWrtMin: Tensor<Float>, backpropWrtMax: Tensor<Float>) {
-  let op = TFE_Op("FakeQuantWithMinMaxVarsPerChannelGradient")
-  op.setAttr("num_bits", numBits)
-  op.setAttr("narrow_range", narrowRange)
-  let _ = op.addInput(gradients)
-  let _ = op.addInput(inputs)
-  let _ = op.addInput(min)
-  let _ = op.addInput(max)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Creates a tensor filled with a scalar value.
-///
-/// This operation creates a tensor of shape `dims` and fills it with `value`.
-///
-/// For example:
-///
-/// ```
-/// # Output tensor has shape [2, 3].
-/// fill([2, 3], 9) ==> [[9, 9, 9]
-///                      [9, 9, 9]]
-/// ```
-///
-/// `tf.fill` differs from `tf.constant` in a few ways:
-///
-/// *   `tf.fill` only supports scalar contents, whereas `tf.constant` supports
-///     Tensor values.
-/// *   `tf.fill` creates an Op in the computation graph that constructs the actual
-///     Tensor value at runtime. This is in contrast to `tf.constant` which embeds
-///     the entire Tensor into the graph with a `Const` node.
-/// *   Because `tf.fill` evaluates at graph runtime, it supports dynamic shapes
-///     based on other runtime Tensors, unlike `tf.constant`.
-///
-/// - Parameters:
-///   - dims: 1-D. Represents the shape of the output tensor.
-///   - value: 0-D (scalar). Value to fill the returned tensor.
-///
-///     @compatibility(numpy)
-///     Equivalent to np.full
-///     @end_compatibility
-@inlinable
-public static func fill<
-    T: TensorFlowScalar,
-    IndexType: BinaryInteger & TensorFlowScalar
->(
-  dims: Tensor<IndexType>,
-  value: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Fill")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("index_type", IndexType.tensorFlowDataType)
-  let _ = op.addInput(dims)
-  let _ = op.addInput(value)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset containing elements of first component of `input_dataset` having true in the last component.
-@inlinable
-public static func filterByLastComponentDataset(
-  inputDataset: VariantHandle,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("FilterByLastComponentDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset containing elements of `input_dataset` matching `predicate`.
-///
-/// The `predicate` function must return a scalar boolean and accept the
-/// following arguments:
-///
-/// * One tensor for each component of an element of `input_dataset`.
-/// * One tensor for each value in `other_arguments`.
-///
-/// - Parameter other_arguments: A list of tensors, typically values that were captured when
-///   building a closure for `predicate`.
-///
-/// - Attr predicate: A function returning a scalar boolean.
-@inlinable
-public static func filterDataset<
-    PredicateIn: TensorGroup,
-    PredicateOut: TensorGroup,
-    Targuments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  otherArguments: Targuments,
-  predicate: (PredicateIn) -> PredicateOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("FilterDataset")
-  op.setAttr("predicate", predicate)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(otherArguments)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func fiveFloatOutputs(
-) -> (a: Tensor<Float>, b: Tensor<Float>, c: Tensor<Float>, d: Tensor<Float>, e: Tensor<Float>) {
-  let op = TFE_Op("FiveFloatOutputs")
-  
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Creates a dataset that emits the records from one or more binary files.
-///
-/// - Parameters:
-///   - filenames: A scalar or a vector containing the name(s) of the file(s) to be
-///     read.
-///   - header_bytes: A scalar representing the number of bytes to skip at the
-///     beginning of a file.
-///   - record_bytes: A scalar representing the number of bytes in each record.
-///   - footer_bytes: A scalar representing the number of bytes to skip at the end
-///     of a file.
-///   - buffer_size: A scalar representing the number of bytes to buffer. Must be > 0.
-@inlinable
-public static func fixedLengthRecordDataset(
-  filenames: StringTensor,
-  headerBytes: Tensor<Int64>,
-  recordBytes: Tensor<Int64>,
-  footerBytes: Tensor<Int64>,
-  bufferSize: Tensor<Int64>
-) -> VariantHandle {
-  let op = TFE_Op("FixedLengthRecordDataset")
-  let _ = op.addInput(filenames)
-  let _ = op.addInput(headerBytes)
-  let _ = op.addInput(recordBytes)
-  let _ = op.addInput(footerBytes)
-  let _ = op.addInput(bufferSize)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func fixedLengthRecordDatasetV2(
-  filenames: StringTensor,
-  headerBytes: Tensor<Int64>,
-  recordBytes: Tensor<Int64>,
-  footerBytes: Tensor<Int64>,
-  bufferSize: Tensor<Int64>,
-  compressionType: StringTensor
-) -> VariantHandle {
-  let op = TFE_Op("FixedLengthRecordDatasetV2")
-  let _ = op.addInput(filenames)
-  let _ = op.addInput(headerBytes)
-  let _ = op.addInput(recordBytes)
-  let _ = op.addInput(footerBytes)
-  let _ = op.addInput(bufferSize)
-  let _ = op.addInput(compressionType)
-  return op.execute(Int(1))
-}
-
-/// A Reader that outputs fixed-length records from a file.
-///
-/// - Attrs:
-///   - header_bytes: Number of bytes in the header, defaults to 0.
-///   - record_bytes: Number of bytes in the record.
-///   - footer_bytes: Number of bytes in the footer, defaults to 0.
-///   - hop_bytes: Number of bytes to hop before each read. Default of 0 means using
-///     record_bytes.
-///   - container: If non-empty, this reader is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this reader is named in the given bucket
-///     with this shared_name. Otherwise, the node name is used instead.
-///   - encoding: The type of encoding for the file. Currently ZLIB and GZIP
-///     are supported. Defaults to none.
-///
-/// - Output reader_handle: The handle to reference the Reader.
-@inlinable
-public static func fixedLengthRecordReaderV2(
-  headerBytes: Int64 = 0,
-  recordBytes: Int64,
-  footerBytes: Int64 = 0,
-  hopBytes: Int64 = 0,
-  container: String,
-  sharedName: String,
-  encoding: String
-) -> ResourceHandle {
-  let op = TFE_Op("FixedLengthRecordReaderV2")
-  op.setAttr("header_bytes", headerBytes)
-  op.setAttr("record_bytes", recordBytes)
-  op.setAttr("footer_bytes", footerBytes)
-  op.setAttr("hop_bytes", hopBytes)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("encoding", encoding)
-  return op.execute(Int(1))
-}
-
-/// Generates labels for candidate sampling with a learned unigram distribution.
-///
-/// A unigram sampler could use a fixed unigram distribution read from a
-/// file or passed in as an in-memory array instead of building up the distribution
-/// from data on the fly. There is also an option to skew the distribution by
-/// applying a distortion power to the weights.
-///
-/// The vocabulary file should be in CSV-like format, with the last field
-/// being the weight associated with the word.
-///
-/// For each batch, this op picks a single set of sampled candidate labels.
-///
-/// The advantages of sampling candidates per-batch are simplicity and the
-/// possibility of efficient dense matrix multiplication. The disadvantage is that
-/// the sampled candidates must be chosen independently of the context and of the
-/// true labels.
-///
-/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
-///   IDs of the num_true target_classes in the corresponding original label.
-///
-/// - Attrs:
-///   - num_true: Number of true labels per context.
-///   - num_sampled: Number of candidates to randomly sample.
-///   - unique: If unique is true, we sample with rejection, so that all sampled
-///     candidates in a batch are unique. This requires some approximation to
-///     estimate the post-rejection sampling probabilities.
-///   - range_max: The sampler will sample integers from the interval [0, range_max).
-///   - vocab_file: Each valid line in this file (which should have a CSV-like format)
-///     corresponds to a valid word ID. IDs are in sequential order, starting from
-///     num_reserved_ids. The last entry in each line is expected to be a value
-///     corresponding to the count or relative probability. Exactly one of vocab_file
-///     and unigrams needs to be passed to this op.
-///   - distortion: The distortion is used to skew the unigram probability distribution.
-///     Each weight is first raised to the distortion's power before adding to the
-///     internal unigram distribution. As a result, distortion = 1.0 gives regular
-///     unigram sampling (as defined by the vocab file), and distortion = 0.0 gives
-///     a uniform distribution.
-///   - num_reserved_ids: Optionally some reserved IDs can be added in the range [0,
-///     ..., num_reserved_ids) by the users. One use case is that a special unknown
-///     word token is used as ID 0. These IDs will have a sampling probability of 0.
-///   - num_shards: A sampler can be used to sample from a subset of the original range
-///     in order to speed up the whole computation through parallelism. This parameter
-///     (together with 'shard') indicates the number of partitions that are being
-///     used in the overall computation.
-///   - shard: A sampler can be used to sample from a subset of the original range
-///     in order to speed up the whole computation through parallelism. This parameter
-///     (together with 'num_shards') indicates the particular partition number of a
-///     sampler op, when partitioning is being used.
-///   - unigrams: A list of unigram counts or probabilities, one per ID in sequential
-///     order. Exactly one of vocab_file and unigrams should be passed to this op.
-///   - seed: If either seed or seed2 are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: An second seed to avoid seed collision.
-///
-/// - Outputs:
-///   - sampled_candidates: A vector of length num_sampled, in which each element is
-///     the ID of a sampled candidate.
-///   - true_expected_count: A batch_size * num_true matrix, representing
-///     the number of times each candidate is expected to occur in a batch
-///     of sampled candidates. If unique=true, then this is a probability.
-///   - sampled_expected_count: A vector of length num_sampled, for each sampled
-///     candidate representing the number of times the candidate is expected
-///     to occur in a batch of sampled candidates.  If unique=true, then this is a
-///     probability.
-@inlinable
-public static func fixedUnigramCandidateSampler(
-  trueClasses: Tensor<Int64>,
-  numTrue: Int64,
-  numSampled: Int64,
-  unique: Bool,
-  rangeMax: Int64,
-  vocabFile: String,
-  distortion: Double = 1,
-  numReservedIds: Int64 = 0,
-  numShards: Int64 = 1,
-  shard: Int64 = 0,
-  unigrams: [Double],
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
-  let op = TFE_Op("FixedUnigramCandidateSampler")
-  op.setAttr("num_true", numTrue)
-  op.setAttr("num_sampled", numSampled)
-  op.setAttr("unique", unique)
-  op.setAttr("range_max", rangeMax)
-  op.setAttr("vocab_file", vocabFile)
-  op.setAttr("distortion", distortion)
-  op.setAttr("num_reserved_ids", numReservedIds)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard", shard)
-  op.setAttr("unigrams", unigrams)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(trueClasses)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
-///
-/// Unlike MapDataset, the `f` in FlatMapDataset is expected to return a
-/// Dataset variant, and FlatMapDataset will flatten successive results
-/// into a single Dataset.
-///
-/// - Attr f: A function mapping elements of `input_dataset`, concatenated with
-///   `other_arguments`, to a Dataset variant that contains elements matching
-///   `output_types` and `output_shapes`.
-@inlinable
-public static func flatMapDataset<
-    FIn: TensorGroup,
-    FOut: TensorGroup,
-    Targuments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  otherArguments: Targuments,
-  f: (FIn) -> FOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("FlatMapDataset")
-  op.setAttr("f", f)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(otherArguments)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func floatInput(
-  _ a: Tensor<Float>
-) {
-  let op = TFE_Op("FloatInput")
-  let _ = op.addInput(a)
-  op.execute()
-}
-
-@inlinable
-public static func floatOutput(
-) -> Tensor<Float> {
-  let op = TFE_Op("FloatOutput")
-  
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func floatOutputStringOutput(
-) -> (a: Tensor<Float>, b: StringTensor) {
-  let op = TFE_Op("FloatOutputStringOutput")
-  
-  return op.execute(Int(1), Int(1))
-}
-
-/// Returns element-wise largest integer not greater than x.
-@inlinable
-public static func floor<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Floor")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns x // y element-wise.
-///
-/// *NOTE*: `FloorDiv` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func floorDiv<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("FloorDiv")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns element-wise remainder of division. When `x < 0` xor `y < 0` is
-///
-/// true, this follows Python semantics in that the result here is consistent
-/// with a flooring divide. E.g. `floor(x / y) * y + mod(x, y) = x`.
-///
-/// *NOTE*: `FloorMod` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func floorMod<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("FloorMod")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func flushSummaryWriter(
-  writer: ResourceHandle
-) {
-  let op = TFE_Op("FlushSummaryWriter")
-  let _ = op.addInput(writer)
-  op.execute()
-}
-
-@inlinable
-public static func foo1(
-  _ a: Tensor<Float>,
-  _ b: Tensor<Int32>,
-  c: Tensor<Int32>
-) -> (d: Tensor<Float>, e: Tensor<Int32>) {
-  let op = TFE_Op("Foo1")
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  let _ = op.addInput(c)
-  return op.execute(Int(1), Int(1))
-}
-
-@inlinable
-public static func foo2(
-  _ a: Tensor<Float>,
-  _ b: StringTensor,
-  c: StringTensor
-) -> (d: Tensor<Float>, e: Tensor<Int32>) {
-  let op = TFE_Op("Foo2")
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  let _ = op.addInput(c)
-  return op.execute(Int(1), Int(1))
-}
-
-@inlinable
-public static func foo3(
-  _ a: Tensor<Float>,
-  _ b: StringTensor,
-  c: Tensor<Float>
-) -> (d: Tensor<Float>, e: Tensor<Int32>) {
-  let op = TFE_Op("Foo3")
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  let _ = op.addInput(c)
-  return op.execute(Int(1), Int(1))
-}
-
-///   ```python
-///    output = input;
-///    for i in range(start, limit, delta)
-///      output = body(i, output);
-///   ```
-///
-/// - Parameters:
-///   - start: The lower bound. An int32
-///   - limit: The upper bound. An int32
-///   - delta: The increment. An int32
-///   - input: A list of input tensors whose types are T.
-///
-/// - Attrs:
-///   - T: A list of dtypes.
-///   - body:     A function that takes a list of tensors (int32, T) and returns another
-///         list of tensors (T).
-///
-/// - Output output: A list of output tensors whose types are T.
-@inlinable
-public static func for_<
-    T: TensorArrayProtocol,
-    BodyIn: TensorGroup,
-    BodyOut: TensorGroup
->(
-  start: Tensor<Int32>,
-  limit: Tensor<Int32>,
-  delta: Tensor<Int32>,
-  _ input: T,
-  body: (BodyIn) -> BodyOut
-) -> T {
-  let op = TFE_Op("For")
-  op.setAttr("T", input._typeList)
-  op.setAttr("body", body)
-  let _ = op.addInput(start)
-  let _ = op.addInput(limit)
-  let _ = op.addInput(delta)
-  let _ = op.addInputList(input)
-  return op.execute(Int(input._typeList.count))
-}
-
-/// Performs fractional average pooling on the input.
-///
-/// Fractional average pooling is similar to Fractional max pooling in the pooling
-/// region generation step. The only difference is that after pooling regions are
-/// generated, a mean operation is performed instead of a max operation in each
-/// pooling region.
-///
-/// - Parameter value: 4-D with shape `[batch, height, width, channels]`.
-///
-/// - Attrs:
-///   - pooling_ratio: Pooling ratio for each dimension of `value`, currently only
-///     supports row and col dimension and should be >= 1.0. For example, a valid
-///     pooling ratio looks like [1.0, 1.44, 1.73, 1.0]. The first and last elements
-///     must be 1.0 because we don't allow pooling on batch and channels
-///     dimensions. 1.44 and 1.73 are pooling ratio on height and width dimensions
-///     respectively.
-///   - pseudo_random: When set to True, generates the pooling sequence in a
-///     pseudorandom fashion, otherwise, in a random fashion. Check paper [Benjamin
-///     Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071) for
-///     difference between pseudorandom and random.
-///   - overlapping: When set to True, it means when pooling, the values at the boundary
-///     of adjacent pooling cells are used by both cells. For example:
-///
-///     `index  0  1  2  3  4`
-///
-///     `value  20 5  16 3  7`
-///
-///     If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
-///     The result would be [41/3, 26/3] for fractional avg pooling.
-///   - deterministic: When set to True, a fixed pooling region will be used when
-///     iterating over a FractionalAvgPool node in the computation graph. Mainly used
-///     in unit test to make FractionalAvgPool deterministic.
-///   - seed: If either seed or seed2 are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: An second seed to avoid seed collision.
-///
-/// - Outputs:
-///   - output: output tensor after fractional avg pooling.
-///   - row_pooling_sequence: row pooling sequence, needed to calculate gradient.
-///   - col_pooling_sequence: column pooling sequence, needed to calculate gradient.
-@inlinable
-public static func fractionalAvgPool<T: Numeric & TensorFlowScalar>(
-  value: Tensor<T>,
-  poolingRatio: [Double],
-  pseudoRandom: Bool = false,
-  overlapping: Bool = false,
-  deterministic: Bool = false,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> (output: Tensor<T>, rowPoolingSequence: Tensor<Int64>, colPoolingSequence: Tensor<Int64>) {
-  let op = TFE_Op("FractionalAvgPool")
-  op.setAttr("pooling_ratio", poolingRatio)
-  op.setAttr("pseudo_random", pseudoRandom)
-  op.setAttr("overlapping", overlapping)
-  op.setAttr("deterministic", deterministic)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(value)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Computes gradient of the FractionalAvgPool function.
-///
-/// Unlike FractionalMaxPoolGrad, we don't need to find arg_max for
-/// FractionalAvgPoolGrad, we just need to evenly back-propagate each element of
-/// out_backprop to those indices that form the same pooling cell. Therefore, we
-/// just need to know the shape of original input tensor, instead of the whole
-/// tensor.
-///
-/// - Parameters:
-///   - orig_input_tensor_shape: Original input tensor shape for `fractional_avg_pool`
-///   - out_backprop: 4-D with shape `[batch, height, width, channels]`.  Gradients
-///     w.r.t. the output of `fractional_avg_pool`.
-///   - row_pooling_sequence: row pooling sequence, form pooling region with
-///     col_pooling_sequence.
-///   - col_pooling_sequence: column pooling sequence, form pooling region with
-///     row_pooling sequence.
-///
-/// - Attr overlapping: When set to True, it means when pooling, the values at the boundary
-///   of adjacent pooling cells are used by both cells. For example:
-///
-///   `index  0  1  2  3  4`
-///
-///   `value  20 5  16 3  7`
-///
-///   If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
-///   The result would be [41/3, 26/3] for fractional avg pooling.
-///
-/// - Output output: 4-D.  Gradients w.r.t. the input of `fractional_avg_pool`.
-@inlinable
-public static func fractionalAvgPoolGrad<T: Numeric & TensorFlowScalar>(
-  origInputTensorShape: Tensor<Int64>,
-  outBackprop: Tensor<T>,
-  rowPoolingSequence: Tensor<Int64>,
-  colPoolingSequence: Tensor<Int64>,
-  overlapping: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("FractionalAvgPoolGrad")
-  op.setAttr("overlapping", overlapping)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(origInputTensorShape)
-  let _ = op.addInput(outBackprop)
-  let _ = op.addInput(rowPoolingSequence)
-  let _ = op.addInput(colPoolingSequence)
-  return op.execute(Int(1))
-}
-
-/// Performs fractional max pooling on the input.
-///
-/// Fractional max pooling is slightly different than regular max pooling.  In
-/// regular max pooling, you downsize an input set by taking the maximum value of
-/// smaller N x N subsections of the set (often 2x2), and try to reduce the set by
-/// a factor of N, where N is an integer.  Fractional max pooling, as you might
-/// expect from the word "fractional", means that the overall reduction ratio N
-/// does not have to be an integer.
-///
-/// The sizes of the pooling regions are generated randomly but are fairly uniform.
-/// For example, let's look at the height dimension, and the constraints on the
-/// list of rows that will be pool boundaries.
-///
-/// First we define the following:
-///
-/// 1.  input_row_length : the number of rows from the input set
-/// 2.  output_row_length : which will be smaller than the input
-/// 3.  alpha = input_row_length / output_row_length : our reduction ratio
-/// 4.  K = floor(alpha)
-/// 5.  row_pooling_sequence : this is the result list of pool boundary rows
-///
-/// Then, row_pooling_sequence should satisfy:
-///
-/// 1.  a[0] = 0 : the first value of the sequence is 0
-/// 2.  a[end] = input_row_length : the last value of the sequence is the size
-/// 3.  K <= (a[i+1] - a[i]) <= K+1 : all intervals are K or K+1 size
-/// 4.  length(row_pooling_sequence) = output_row_length+1
-///
-/// For more details on fractional max pooling, see this paper:
-/// [Benjamin Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071)
-///
-/// - Parameter value: 4-D with shape `[batch, height, width, channels]`.
-///
-/// - Attrs:
-///   - pooling_ratio: Pooling ratio for each dimension of `value`, currently only
-///     supports row and col dimension and should be >= 1.0. For example, a valid
-///     pooling ratio looks like [1.0, 1.44, 1.73, 1.0]. The first and last elements
-///     must be 1.0 because we don't allow pooling on batch and channels
-///     dimensions. 1.44 and 1.73 are pooling ratio on height and width dimensions
-///     respectively.
-///   - pseudo_random: When set to True, generates the pooling sequence in a
-///     pseudorandom fashion, otherwise, in a random fashion. Check paper [Benjamin
-///     Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071) for
-///     difference between pseudorandom and random.
-///   - overlapping: When set to True, it means when pooling, the values at the boundary
-///     of adjacent pooling cells are used by both cells. For example:
-///
-///     `index  0  1  2  3  4`
-///
-///     `value  20 5  16 3  7`
-///
-///     If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
-///     The result would be [20, 16] for fractional max pooling.
-///   - deterministic: When set to True, a fixed pooling region will be used when
-///     iterating over a FractionalMaxPool node in the computation graph. Mainly used
-///     in unit test to make FractionalMaxPool deterministic.
-///   - seed: If either seed or seed2 are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: An second seed to avoid seed collision.
-///
-/// - Outputs:
-///   - output: output tensor after fractional max pooling.
-///   - row_pooling_sequence: row pooling sequence, needed to calculate gradient.
-///   - col_pooling_sequence: column pooling sequence, needed to calculate gradient.
-@inlinable
-public static func fractionalMaxPool<T: Numeric & TensorFlowScalar>(
-  value: Tensor<T>,
-  poolingRatio: [Double],
-  pseudoRandom: Bool = false,
-  overlapping: Bool = false,
-  deterministic: Bool = false,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> (output: Tensor<T>, rowPoolingSequence: Tensor<Int64>, colPoolingSequence: Tensor<Int64>) {
-  let op = TFE_Op("FractionalMaxPool")
-  op.setAttr("pooling_ratio", poolingRatio)
-  op.setAttr("pseudo_random", pseudoRandom)
-  op.setAttr("overlapping", overlapping)
-  op.setAttr("deterministic", deterministic)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(value)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Computes gradient of the FractionalMaxPool function.
-///
-/// - Parameters:
-///   - orig_input: Original input for `fractional_max_pool`
-///   - orig_output: Original output for `fractional_max_pool`
-///   - out_backprop: 4-D with shape `[batch, height, width, channels]`.  Gradients
-///     w.r.t. the output of `fractional_max_pool`.
-///   - row_pooling_sequence: row pooling sequence, form pooling region with
-///     col_pooling_sequence.
-///   - col_pooling_sequence: column pooling sequence, form pooling region with
-///     row_pooling sequence.
-///
-/// - Attr overlapping: When set to True, it means when pooling, the values at the boundary
-///   of adjacent pooling cells are used by both cells. For example:
-///
-///   `index  0  1  2  3  4`
-///
-///   `value  20 5  16 3  7`
-///
-///   If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
-///   The result would be [20, 16] for fractional max pooling.
-///
-/// - Output output: 4-D.  Gradients w.r.t. the input of `fractional_max_pool`.
-@inlinable
-public static func fractionalMaxPoolGrad<T: Numeric & TensorFlowScalar>(
-  origInput: Tensor<T>,
-  origOutput: Tensor<T>,
-  outBackprop: Tensor<T>,
-  rowPoolingSequence: Tensor<Int64>,
-  colPoolingSequence: Tensor<Int64>,
-  overlapping: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("FractionalMaxPoolGrad")
-  op.setAttr("overlapping", overlapping)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(origInput)
-  let _ = op.addInput(origOutput)
-  let _ = op.addInput(outBackprop)
-  let _ = op.addInput(rowPoolingSequence)
-  let _ = op.addInput(colPoolingSequence)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func funcAttr<FIn: TensorGroup,
-    FOut: TensorGroup>(
-  f: (FIn) -> FOut
-) {
-  let op = TFE_Op("FuncAttr")
-  op.setAttr("f", f)
-  op.execute()
-}
-
-/// Batch normalization.
-///
-/// Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
-/// The size of 1D Tensors matches the dimension C of the 4D Tensors.
-///
-/// - Parameters:
-///   - x: A 4D Tensor for input data.
-///   - scale: A 1D Tensor for scaling factor, to scale the normalized x.
-///   - offset: A 1D Tensor for offset, to shift to the normalized x.
-///   - mean: A 1D Tensor for population mean. Used for inference only;
-///     must be empty for training.
-///   - variance: A 1D Tensor for population variance. Used for inference only;
-///     must be empty for training.
-///
-/// - Attrs:
-///   - T: The data type for the elements of input and output Tensors.
-///   - epsilon: A small float number added to the variance of x.
-///   - data_format: The data format for x and y. Either "NHWC" (default) or "NCHW".
-///   - is_training: A bool value to indicate the operation is for training (default)
-///     or inference.
-///
-/// - Outputs:
-///   - y: A 4D Tensor for output data.
-///   - batch_mean: A 1D Tensor for the computed batch mean, to be used by TensorFlow
-///     to compute the running mean.
-///   - batch_variance: A 1D Tensor for the computed batch variance, to be used by
-///     TensorFlow to compute the running variance.
-///   - reserve_space_1: A 1D Tensor for the computed batch mean, to be reused
-///     in the gradient computation.
-///   - reserve_space_2: A 1D Tensor for the computed batch variance (inverted variance
-///     in the cuDNN case), to be reused in the gradient computation.
-@inlinable
-public static func fusedBatchNorm<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  scale: Tensor<T>,
-  offset: Tensor<T>,
-  mean: Tensor<T>,
-  variance: Tensor<T>,
-  epsilon: Double = 0.0001,
-  dataFormat: DataFormat = .nhwc,
-  isTraining: Bool = true
-) -> (y: Tensor<T>, batchMean: Tensor<T>, batchVariance: Tensor<T>, reserveSpace1: Tensor<T>, reserveSpace2: Tensor<T>) {
-  let op = TFE_Op("FusedBatchNorm")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("epsilon", epsilon)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("is_training", isTraining)
-  let _ = op.addInput(x)
-  let _ = op.addInput(scale)
-  let _ = op.addInput(offset)
-  let _ = op.addInput(mean)
-  let _ = op.addInput(variance)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Gradient for batch normalization.
-///
-/// Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
-/// The size of 1D Tensors matches the dimension C of the 4D Tensors.
-///
-/// - Parameters:
-///   - y_backprop: A 4D Tensor for the gradient with respect to y.
-///   - x: A 4D Tensor for input data.
-///   - scale: A 1D Tensor for scaling factor, to scale the normalized x.
-///   - reserve_space_1: When is_training is True, a 1D Tensor for the computed batch
-///     mean to be reused in gradient computation. When is_training is
-///     False, a 1D Tensor for the population mean to be reused in both
-///     1st and 2nd order gradient computation.
-///   - reserve_space_2: When is_training is True, a 1D Tensor for the computed batch
-///     variance (inverted variance in the cuDNN case) to be reused in
-///     gradient computation. When is_training is False, a 1D Tensor
-///     for the population variance to be reused in both 1st and 2nd
-///     order gradient computation.
-///
-/// - Attrs:
-///   - T: The data type for the elements of input and output Tensors.
-///   - epsilon: A small float number added to the variance of x.
-///   - data_format: The data format for y_backprop, x, x_backprop.
-///     Either "NHWC" (default) or "NCHW".
-///   - is_training: A bool value to indicate the operation is for training (default)
-///     or inference.
-///
-/// - Outputs:
-///   - x_backprop: A 4D Tensor for the gradient with respect to x.
-///   - scale_backprop: A 1D Tensor for the gradient with respect to scale.
-///   - offset_backprop: A 1D Tensor for the gradient with respect to offset.
-///   - reserve_space_3: Unused placeholder to match the mean input in FusedBatchNorm.
-///   - reserve_space_4: Unused placeholder to match the variance input
-///     in FusedBatchNorm.
-@inlinable
-public static func fusedBatchNormGrad<T: FloatingPoint & TensorFlowScalar>(
-  yBackprop: Tensor<T>,
-  _ x: Tensor<T>,
-  scale: Tensor<T>,
-  reserveSpace1: Tensor<T>,
-  reserveSpace2: Tensor<T>,
-  epsilon: Double = 0.0001,
-  dataFormat: DataFormat = .nhwc,
-  isTraining: Bool = true
-) -> (xBackprop: Tensor<T>, scaleBackprop: Tensor<T>, offsetBackprop: Tensor<T>, reserveSpace3: Tensor<T>, reserveSpace4: Tensor<T>) {
-  let op = TFE_Op("FusedBatchNormGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("epsilon", epsilon)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("is_training", isTraining)
-  let _ = op.addInput(yBackprop)
-  let _ = op.addInput(x)
-  let _ = op.addInput(scale)
-  let _ = op.addInput(reserveSpace1)
-  let _ = op.addInput(reserveSpace2)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Gradient for batch normalization.
-///
-/// Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
-/// The size of 1D Tensors matches the dimension C of the 4D Tensors.
-///
-/// - Parameters:
-///   - y_backprop: A 4D Tensor for the gradient with respect to y.
-///   - x: A 4D Tensor for input data.
-///   - scale: A 1D Tensor for scaling factor, to scale the normalized x.
-///   - reserve_space_1: When is_training is True, a 1D Tensor for the computed batch
-///     mean to be reused in gradient computation. When is_training is
-///     False, a 1D Tensor for the population mean to be reused in both
-///     1st and 2nd order gradient computation.
-///   - reserve_space_2: When is_training is True, a 1D Tensor for the computed batch
-///     variance (inverted variance in the cuDNN case) to be reused in
-///     gradient computation. When is_training is False, a 1D Tensor
-///     for the population variance to be reused in both 1st and 2nd
-///     order gradient computation.
-///
-/// - Attrs:
-///   - T: The data type for the elements of input and output Tensors.
-///   - U: The data type for the scale, offset, mean, and variance.
-///   - epsilon: A small float number added to the variance of x.
-///   - data_format: The data format for y_backprop, x, x_backprop.
-///     Either "NHWC" (default) or "NCHW".
-///   - is_training: A bool value to indicate the operation is for training (default)
-///     or inference.
-///
-/// - Outputs:
-///   - x_backprop: A 4D Tensor for the gradient with respect to x.
-///   - scale_backprop: A 1D Tensor for the gradient with respect to scale.
-///   - offset_backprop: A 1D Tensor for the gradient with respect to offset.
-///   - reserve_space_3: Unused placeholder to match the mean input in FusedBatchNorm.
-///   - reserve_space_4: Unused placeholder to match the variance input
-///     in FusedBatchNorm.
-@inlinable
-public static func fusedBatchNormGradV2<
-    T: FloatingPoint & TensorFlowScalar,
-    U: FloatingPoint & TensorFlowScalar
->(
-  yBackprop: Tensor<T>,
-  _ x: Tensor<T>,
-  scale: Tensor<Float>,
-  reserveSpace1: Tensor<U>,
-  reserveSpace2: Tensor<U>,
-  epsilon: Double = 0.0001,
-  dataFormat: DataFormat = .nhwc,
-  isTraining: Bool = true
-) -> (xBackprop: Tensor<T>, scaleBackprop: Tensor<U>, offsetBackprop: Tensor<U>, reserveSpace3: Tensor<U>, reserveSpace4: Tensor<U>) {
-  let op = TFE_Op("FusedBatchNormGradV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("U", U.tensorFlowDataType)
-  op.setAttr("epsilon", epsilon)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("is_training", isTraining)
-  let _ = op.addInput(yBackprop)
-  let _ = op.addInput(x)
-  let _ = op.addInput(scale)
-  let _ = op.addInput(reserveSpace1)
-  let _ = op.addInput(reserveSpace2)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Batch normalization.
-///
-/// Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
-/// The size of 1D Tensors matches the dimension C of the 4D Tensors.
-///
-/// - Parameters:
-///   - x: A 4D Tensor for input data.
-///   - scale: A 1D Tensor for scaling factor, to scale the normalized x.
-///   - offset: A 1D Tensor for offset, to shift to the normalized x.
-///   - mean: A 1D Tensor for population mean. Used for inference only;
-///     must be empty for training.
-///   - variance: A 1D Tensor for population variance. Used for inference only;
-///     must be empty for training.
-///
-/// - Attrs:
-///   - T: The data type for the elements of input and output Tensors.
-///   - U: The data type for the scale, offset, mean, and variance.
-///   - epsilon: A small float number added to the variance of x.
-///   - data_format: The data format for x and y. Either "NHWC" (default) or "NCHW".
-///   - is_training: A bool value to indicate the operation is for training (default)
-///     or inference.
-///
-/// - Outputs:
-///   - y: A 4D Tensor for output data.
-///   - batch_mean: A 1D Tensor for the computed batch mean, to be used by TensorFlow
-///     to compute the running mean.
-///   - batch_variance: A 1D Tensor for the computed batch variance, to be used by
-///     TensorFlow to compute the running variance.
-///   - reserve_space_1: A 1D Tensor for the computed batch mean, to be reused
-///     in the gradient computation.
-///   - reserve_space_2: A 1D Tensor for the computed batch variance (inverted variance
-///     in the cuDNN case), to be reused in the gradient computation.
-@inlinable
-public static func fusedBatchNormV2<
-    T: FloatingPoint & TensorFlowScalar,
-    U: FloatingPoint & TensorFlowScalar
->(
-  _ x: Tensor<T>,
-  scale: Tensor<U>,
-  offset: Tensor<U>,
-  mean: Tensor<U>,
-  variance: Tensor<U>,
-  epsilon: Double = 0.0001,
-  dataFormat: DataFormat = .nhwc,
-  isTraining: Bool = true
-) -> (y: Tensor<T>, batchMean: Tensor<U>, batchVariance: Tensor<U>, reserveSpace1: Tensor<U>, reserveSpace2: Tensor<U>) {
-  let op = TFE_Op("FusedBatchNormV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("U", U.tensorFlowDataType)
-  op.setAttr("epsilon", epsilon)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("is_training", isTraining)
-  let _ = op.addInput(x)
-  let _ = op.addInput(scale)
-  let _ = op.addInput(offset)
-  let _ = op.addInput(mean)
-  let _ = op.addInput(variance)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Performs a padding as a preprocess during a convolution.
-///
-/// Similar to FusedResizeAndPadConv2d, this op allows for an optimized
-/// implementation where the spatial padding transformation stage is fused with the
-/// im2col lookup, but in this case without the bilinear filtering required for
-/// resizing. Fusing the padding prevents the need to write out the intermediate
-/// results as whole tensors, reducing memory pressure, and we can get some latency
-/// gains by merging the transformation calculations.
-/// The data_format attribute for Conv2D isn't supported by this op, and 'NHWC'
-/// order is used instead.
-/// Internally this op uses a single per-graph scratch buffer, which means that it
-/// will block if multiple versions are being run in parallel. This is because this
-/// operator is primarily an optimization to minimize memory usage.
-///
-/// - Parameters:
-///   - input: 4-D with shape `[batch, in_height, in_width, in_channels]`.
-///   - paddings: A two-column matrix specifying the padding sizes. The number of
-///     rows must be the same as the rank of `input`.
-///   - filter: 4-D with shape
-///     `[filter_height, filter_width, in_channels, out_channels]`.
-///
-/// - Attrs:
-///   - strides: 1-D of length 4.  The stride of the sliding window for each dimension
-///     of `input`. Must be in the same order as the dimension specified with format.
-///   - padding: The type of padding algorithm to use.
-@inlinable
-public static func fusedPadConv2D<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  paddings: Tensor<Int32>,
-  filter: Tensor<T>,
-  mode: Mode5,
-  strides: [Int32],
-  padding: Padding
-) -> Tensor<T> {
-  let op = TFE_Op("FusedPadConv2D")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("mode", mode.cName)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(paddings)
-  let _ = op.addInput(filter)
-  return op.execute(Int(1))
-}
-
-/// Performs a resize and padding as a preprocess during a convolution.
-///
-/// It's often possible to do spatial transformations more efficiently as part of
-/// the packing stage of a convolution, so this op allows for an optimized
-/// implementation where these stages are fused together. This prevents the need to
-/// write out the intermediate results as whole tensors, reducing memory pressure,
-/// and we can get some latency gains by merging the transformation calculations.
-/// The data_format attribute for Conv2D isn't supported by this op, and defaults to
-/// 'NHWC' order.
-/// Internally this op uses a single per-graph scratch buffer, which means that it
-/// will block if multiple versions are being run in parallel. This is because this
-/// operator is primarily an optimization to minimize memory usage.
-///
-/// - Parameters:
-///   - input: 4-D with shape `[batch, in_height, in_width, in_channels]`.
-///   - size: A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
-///     new size for the images.
-///   - paddings: A two-column matrix specifying the padding sizes. The number of
-///     rows must be the same as the rank of `input`.
-///   - filter: 4-D with shape
-///     `[filter_height, filter_width, in_channels, out_channels]`.
-///
-/// - Attrs:
-///   - resize_align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
-///     aligned, preserving the values at the corner pixels. Defaults to false.
-///   - strides: 1-D of length 4.  The stride of the sliding window for each dimension
-///     of `input`. Must be in the same order as the dimension specified with format.
-///   - padding: The type of padding algorithm to use.
-@inlinable
-public static func fusedResizeAndPadConv2D<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  size: Tensor<Int32>,
-  paddings: Tensor<Int32>,
-  filter: Tensor<T>,
-  resizeAlignCorners: Bool = false,
-  mode: Mode5,
-  strides: [Int32],
-  padding: Padding
-) -> Tensor<T> {
-  let op = TFE_Op("FusedResizeAndPadConv2D")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("resize_align_corners", resizeAlignCorners)
-  op.setAttr("mode", mode.cName)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(size)
-  let _ = op.addInput(paddings)
-  let _ = op.addInput(filter)
-  return op.execute(Int(1))
-}
-
-/// Computes the GRU cell forward propagation for 1 time step.
-///
-/// Args
-///     x: Input to the GRU cell.
-///     h_prev: State input from the previous GRU cell.
-///     w_ru: Weight matrix for the reset and update gate.
-///     w_c: Weight matrix for the cell connection gate.
-///     b_ru: Bias vector for the reset and update gate.
-///     b_c: Bias vector for the cell connection gate.
-///
-/// Returns
-///     r: Output of the reset gate.
-///     u: Output of the update gate.
-///     c: Output of the cell connection gate.
-///     h: Current state of the GRU cell.
-///
-/// Note on notation of the variables:
-///
-/// Concatenation of a and b is represented by a_b
-/// Element-wise dot product of a and b is represented by ab
-/// Element-wise dot product is represented by \circ
-/// Matrix multiplication is represented by *
-///
-/// Biases are initialized with :
-/// `b_ru` - constant_initializer(1.0)
-/// `b_c` - constant_initializer(0.0)
-///
-/// This kernel op implements the following mathematical equations:
-///
-/// ```
-/// x_h_prev = [x, h_prev]
-///
-/// [r_bar u_bar] = x_h_prev * w_ru + b_ru
-///
-/// r = sigmoid(r_bar)
-/// u = sigmoid(u_bar)
-///
-/// h_prevr = h_prev \circ r
-///
-/// x_h_prevr = [x h_prevr]
-///
-/// c_bar = x_h_prevr * w_c + b_c
-/// c = tanh(c_bar)
-///
-/// h = (1-u) \circ c + u \circ h_prev
-/// ```
-@inlinable
-public static func gRUBlockCell<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  hPrev: Tensor<T>,
-  wRu: Tensor<T>,
-  wC: Tensor<T>,
-  bRu: Tensor<T>,
-  bC: Tensor<T>
-) -> (r: Tensor<T>, u: Tensor<T>, c: Tensor<T>, h: Tensor<T>) {
-  let op = TFE_Op("GRUBlockCell")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(hPrev)
-  let _ = op.addInput(wRu)
-  let _ = op.addInput(wC)
-  let _ = op.addInput(bRu)
-  let _ = op.addInput(bC)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Computes the GRU cell back-propagation for 1 time step.
-///
-/// Args
-///     x: Input to the GRU cell.
-///     h_prev: State input from the previous GRU cell.
-///     w_ru: Weight matrix for the reset and update gate.
-///     w_c: Weight matrix for the cell connection gate.
-///     b_ru: Bias vector for the reset and update gate.
-///     b_c: Bias vector for the cell connection gate.
-///     r: Output of the reset gate.
-///     u: Output of the update gate.
-///     c: Output of the cell connection gate.
-///     d_h: Gradients of the h_new wrt to objective function.
-///
-/// Returns
-///     d_x: Gradients of the x wrt to objective function.
-///     d_h_prev: Gradients of the h wrt to objective function.
-///     d_c_bar Gradients of the c_bar wrt to objective function.
-///     d_r_bar_u_bar Gradients of the r_bar & u_bar wrt to objective function.
-///
-/// This kernel op implements the following mathematical equations:
-///
-/// Note on notation of the variables:
-///
-/// Concatenation of a and b is represented by a_b
-/// Element-wise dot product of a and b is represented by ab
-/// Element-wise dot product is represented by \circ
-/// Matrix multiplication is represented by *
-///
-/// Additional notes for clarity:
-///
-/// `w_ru` can be segmented into 4 different matrices.
-/// ```
-/// w_ru = [w_r_x w_u_x
-///         w_r_h_prev w_u_h_prev]
-/// ```
-/// Similarly, `w_c` can be segmented into 2 different matrices.
-/// ```
-/// w_c = [w_c_x w_c_h_prevr]
-/// ```
-/// Same goes for biases.
-/// ```
-/// b_ru = [b_ru_x b_ru_h]
-/// b_c = [b_c_x b_c_h]
-/// ```
-/// Another note on notation:
-/// ```
-/// d_x = d_x_component_1 + d_x_component_2
-///
-/// where d_x_component_1 = d_r_bar * w_r_x^T + d_u_bar * w_r_x^T
-/// and d_x_component_2 = d_c_bar * w_c_x^T
-///
-/// d_h_prev = d_h_prev_component_1 + d_h_prevr \circ r + d_h \circ u
-/// where d_h_prev_componenet_1 = d_r_bar * w_r_h_prev^T + d_u_bar * w_r_h_prev^T
-/// ```
-///
-/// Mathematics behind the Gradients below:
-/// ```
-/// d_c_bar = d_h \circ (1-u) \circ (1-c \circ c)
-/// d_u_bar = d_h \circ (h-c) \circ u \circ (1-u)
-///
-/// d_r_bar_u_bar = [d_r_bar d_u_bar]
-///
-/// [d_x_component_1 d_h_prev_component_1] = d_r_bar_u_bar * w_ru^T
-///
-/// [d_x_component_2 d_h_prevr] = d_c_bar * w_c^T
-///
-/// d_x = d_x_component_1 + d_x_component_2
-///
-/// d_h_prev = d_h_prev_component_1 + d_h_prevr \circ r + u
-/// ```
-/// Below calculation is performed in the python wrapper for the Gradients
-/// (not in the gradient kernel.)
-/// ```
-/// d_w_ru = x_h_prevr^T * d_c_bar
-///
-/// d_w_c = x_h_prev^T * d_r_bar_u_bar
-///
-/// d_b_ru = sum of d_r_bar_u_bar along axis = 0
-///
-/// d_b_c = sum of d_c_bar along axis = 0
-/// ```
-@inlinable
-public static func gRUBlockCellGrad<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  hPrev: Tensor<T>,
-  wRu: Tensor<T>,
-  wC: Tensor<T>,
-  bRu: Tensor<T>,
-  bC: Tensor<T>,
-  r: Tensor<T>,
-  u: Tensor<T>,
-  c: Tensor<T>,
-  dH: Tensor<T>
-) -> (dX: Tensor<T>, dHPrev: Tensor<T>, dCBar: Tensor<T>, dRBarUBar: Tensor<T>) {
-  let op = TFE_Op("GRUBlockCellGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(hPrev)
-  let _ = op.addInput(wRu)
-  let _ = op.addInput(wC)
-  let _ = op.addInput(bRu)
-  let _ = op.addInput(bC)
-  let _ = op.addInput(r)
-  let _ = op.addInput(u)
-  let _ = op.addInput(c)
-  let _ = op.addInput(dH)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Gather slices from `params` according to `indices`.
-///
-/// `indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
-/// Produces an output tensor with shape `indices.shape + params.shape[1:]` where:
-///
-/// ```python
-///     # Scalar indices
-///     output[:, ..., :] = params[indices, :, ... :]
-///
-///     # Vector indices
-///     output[i, :, ..., :] = params[indices[i], :, ... :]
-///
-///     # Higher rank indices
-///     output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
-/// ```
-///
-/// If `indices` is a permutation and `len(indices) == params.shape[0]` then
-/// this operation will permute `params` accordingly.
-///
-/// `validate_indices`: DEPRECATED. If this operation is assigned to CPU, values in
-/// `indices` are always validated to be within range. If assigned to GPU,
-/// out-of-bound indices result in safe but unspecified behavior, which may include
-/// raising an error.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
-/// </div>
-@inlinable
-public static func gather<
-    Tparams: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  params: Tensor<Tparams>,
-  indices: Tensor<Tindices>,
-  validateIndices: Bool = true
-) -> Tensor<Tparams> {
-  let op = TFE_Op("Gather")
-  op.setAttr("validate_indices", validateIndices)
-  op.setAttr("Tparams", Tparams.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(params)
-  let _ = op.addInput(indices)
-  return op.execute(Int(1))
-}
-
-/// Gather slices from `params` into a Tensor with shape specified by `indices`.
-///
-/// `indices` is an K-dimensional integer tensor, best thought of as a
-/// (K-1)-dimensional tensor of indices into `params`, where each element defines a
-/// slice of `params`:
-///
-///     output[\\(i_0, ..., i_{K-2}\\)] = params[indices[\\(i_0, ..., i_{K-2}\\)]]
-///
-/// Whereas in `tf.gather` `indices` defines slices into the first
-/// dimension of `params`, in `tf.gather_nd`, `indices` defines slices into the
-/// first `N` dimensions of `params`, where `N = indices.shape[-1]`.
-///
-/// The last dimension of `indices` can be at most the rank of
-/// `params`:
-///
-///     indices.shape[-1] <= params.rank
-///
-/// The last dimension of `indices` corresponds to elements
-/// (if `indices.shape[-1] == params.rank`) or slices
-/// (if `indices.shape[-1] < params.rank`) along dimension `indices.shape[-1]`
-/// of `params`.  The output tensor has shape
-///
-///     indices.shape[:-1] + params.shape[indices.shape[-1]:]
-///
-/// Note that on CPU, if an out of bound index is found, an error is returned.
-/// On GPU, if an out of bound index is found, a 0 is stored in the
-/// corresponding output value.
-///
-/// Some examples below.
-///
-/// Simple indexing into a matrix:
-///
-/// ```python
-///     indices = [[0, 0], [1, 1]]
-///     params = [['a', 'b'], ['c', 'd']]
-///     output = ['a', 'd']
-/// ```
-///
-/// Slice indexing into a matrix:
-///
-/// ```python
-///     indices = [[1], [0]]
-///     params = [['a', 'b'], ['c', 'd']]
-///     output = [['c', 'd'], ['a', 'b']]
-/// ```
-///
-/// Indexing into a 3-tensor:
-///
-/// ```python
-///     indices = [[1]]
-///     params = [[['a0', 'b0'], ['c0', 'd0']],
-///               [['a1', 'b1'], ['c1', 'd1']]]
-///     output = [[['a1', 'b1'], ['c1', 'd1']]]
-///
-///
-///     indices = [[0, 1], [1, 0]]
-///     params = [[['a0', 'b0'], ['c0', 'd0']],
-///               [['a1', 'b1'], ['c1', 'd1']]]
-///     output = [['c0', 'd0'], ['a1', 'b1']]
-///
-///
-///     indices = [[0, 0, 1], [1, 0, 1]]
-///     params = [[['a0', 'b0'], ['c0', 'd0']],
-///               [['a1', 'b1'], ['c1', 'd1']]]
-///     output = ['b0', 'b1']
-/// ```
-///
-/// Batched indexing into a matrix:
-///
-/// ```python
-///     indices = [[[0, 0]], [[0, 1]]]
-///     params = [['a', 'b'], ['c', 'd']]
-///     output = [['a'], ['b']]
-/// ```
-///
-/// Batched slice indexing into a matrix:
-///
-/// ```python
-///     indices = [[[1]], [[0]]]
-///     params = [['a', 'b'], ['c', 'd']]
-///     output = [[['c', 'd']], [['a', 'b']]]
-/// ```
-///
-/// Batched indexing into a 3-tensor:
-///
-/// ```python
-///     indices = [[[1]], [[0]]]
-///     params = [[['a0', 'b0'], ['c0', 'd0']],
-///               [['a1', 'b1'], ['c1', 'd1']]]
-///     output = [[[['a1', 'b1'], ['c1', 'd1']]],
-///               [[['a0', 'b0'], ['c0', 'd0']]]]
-///
-///     indices = [[[0, 1], [1, 0]], [[0, 0], [1, 1]]]
-///     params = [[['a0', 'b0'], ['c0', 'd0']],
-///               [['a1', 'b1'], ['c1', 'd1']]]
-///     output = [[['c0', 'd0'], ['a1', 'b1']],
-///               [['a0', 'b0'], ['c1', 'd1']]]
-///
-///
-///     indices = [[[0, 0, 1], [1, 0, 1]], [[0, 1, 1], [1, 1, 0]]]
-///     params = [[['a0', 'b0'], ['c0', 'd0']],
-///               [['a1', 'b1'], ['c1', 'd1']]]
-///     output = [['b0', 'b1'], ['d0', 'c1']]
-/// ```
-///
-/// See also `tf.gather` and `tf.batch_gather`.
-///
-/// - Parameters:
-///   - params: The tensor from which to gather values.
-///   - indices: Index tensor.
-///
-/// - Output output: Values from `params` gathered from indices given by `indices`, with
-///   shape `indices.shape[:-1] + params.shape[indices.shape[-1]:]`.
-@inlinable
-public static func gatherNd<
-    Tparams: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  params: Tensor<Tparams>,
-  indices: Tensor<Tindices>
-) -> Tensor<Tparams> {
-  let op = TFE_Op("GatherNd")
-  op.setAttr("Tparams", Tparams.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(params)
-  let _ = op.addInput(indices)
-  return op.execute(Int(1))
-}
-
-/// Gather slices from `params` axis `axis` according to `indices`.
-///
-/// `indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
-/// Produces an output tensor with shape `params.shape[:axis] + indices.shape +
-/// params.shape[axis + 1:]` where:
-///
-/// ```python
-///     # Scalar indices (output is rank(params) - 1).
-///     output[a_0, ..., a_n, b_0, ..., b_n] =
-///       params[a_0, ..., a_n, indices, b_0, ..., b_n]
-///
-///     # Vector indices (output is rank(params)).
-///     output[a_0, ..., a_n, i, b_0, ..., b_n] =
-///       params[a_0, ..., a_n, indices[i], b_0, ..., b_n]
-///
-///     # Higher rank indices (output is rank(params) + rank(indices) - 1).
-///     output[a_0, ..., a_n, i, ..., j, b_0, ... b_n] =
-///       params[a_0, ..., a_n, indices[i, ..., j], b_0, ..., b_n]
-/// ```
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
-/// </div>
-///
-/// Note that on CPU, if an out of bound index is found, an error is returned.
-/// On GPU, if an out of bound index is found, a 0 is stored in the
-/// corresponding output value.
-///
-/// See also `tf.batch_gather` and `tf.gather_nd`.
-///
-/// - Parameters:
-///   - params: The tensor from which to gather values. Must be at least rank
-///     `axis + 1`.
-///   - indices: Index tensor. Must be in range `[0, params.shape[axis])`.
-///   - axis: The axis in `params` to gather `indices` from. Defaults to the first
-///     dimension. Supports negative indexes.
-///
-/// - Output output: Values from `params` gathered from indices given by `indices`, with
-///   shape `params.shape[:axis] + indices.shape + params.shape[axis + 1:]`.
-@inlinable
-public static func gatherV2<
-    Tparams: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar,
-    Taxis: BinaryInteger & TensorFlowScalar
->(
-  params: Tensor<Tparams>,
-  indices: Tensor<Tindices>,
-  axis: Tensor<Taxis>
-) -> Tensor<Tparams> {
-  let op = TFE_Op("GatherV2")
-  op.setAttr("Tparams", Tparams.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("Taxis", Taxis.tensorFlowDataType)
-  let _ = op.addInput(params)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(axis)
-  return op.execute(Int(1))
-}
-
-/// Re-configures the GCS block cache with the new configuration values.
-///
-/// If the values are the same as already configured values, this op is a no-op. If
-/// they are different, the current contents of the block cache is dropped, and a
-/// new block cache is created fresh.
-@inlinable
-public static func gcsConfigureBlockCache(
-  maxCacheSize: Tensor<UInt64>,
-  blockSize: Tensor<UInt64>,
-  maxStaleness: Tensor<UInt64>
-) {
-  let op = TFE_Op("GcsConfigureBlockCache")
-  let _ = op.addInput(maxCacheSize)
-  let _ = op.addInput(blockSize)
-  let _ = op.addInput(maxStaleness)
-  op.execute()
-}
-
-/// Configures the credentials used by the GCS client of the local TF runtime.
-///
-/// The json input can be of the format:
-///
-/// 1. Refresh Token:
-/// {
-///   "client_id": "<redacted>",
-///   "client_secret": "<redacted>",
-///   "refresh_token: "<redacted>",
-///   "type": "authorized_user",
-/// }
-///
-/// 2. Service Account:
-/// {
-///   "type": "service_account",
-///   "project_id": "<redacted>",
-///   "private_key_id": "<redacted>",
-///   "private_key": "------BEGIN PRIVATE KEY-----\n<REDACTED>\n-----END PRIVATE KEY------\n",
-///   "client_email": "<REDACTED>@<REDACTED>.iam.gserviceaccount.com",
-///   "client_id": "<REDACTED>",
-///   # Some additional fields elided
-/// }
-///
-/// Note the credentials established through this method are shared across all
-/// sessions run on this runtime.
-///
-/// Note be sure to feed the inputs to this op to ensure the credentials are not
-/// stored in a constant op within the graph that might accidentally be checkpointed
-/// or in other ways be persisted or exfiltrated.
-@inlinable
-public static func gcsConfigureCredentials(
-  json: StringTensor
-) {
-  let op = TFE_Op("GcsConfigureCredentials")
-  let _ = op.addInput(json)
-  op.execute()
-}
-
-/// Generates serialized partition messages suitable for batch reads.
-///
-/// This op should not be used directly by clients. Instead, the
-/// bigquery_reader_ops.py file defines a clean interface to the reader.
-///
-/// - Attrs:
-///   - project_id: GCP project ID.
-///   - dataset_id: BigQuery Dataset ID.
-///   - table_id: Table to read.
-///   - columns: List of columns to read. Leave empty to read all columns.
-///   - timestamp_millis: Table snapshot timestamp in millis since epoch. Relative
-///     (negative or zero) snapshot times are not allowed. For more details, see
-///     'Table Decorators' in BigQuery docs.
-///   - num_partitions: Number of partitions to split the table into.
-///   - test_end_point: Do not use. For testing purposes only.
-///
-/// - Output partitions: Serialized table partitions.
-@inlinable
-public static func generateBigQueryReaderPartitions(
-  projectId: String,
-  datasetId: String,
-  tableId: String,
-  columns: [String],
-  timestampMillis: Int64,
-  numPartitions: Int64,
-  testEndPoint: String
-) -> StringTensor {
-  let op = TFE_Op("GenerateBigQueryReaderPartitions")
-  op.setAttr("project_id", projectId)
-  op.setAttr("dataset_id", datasetId)
-  op.setAttr("table_id", tableId)
-  op.setAttr("columns", columns)
-  op.setAttr("timestamp_millis", timestampMillis)
-  op.setAttr("num_partitions", numPartitions)
-  op.setAttr("test_end_point", testEndPoint)
-  return op.execute(Int(1))
-}
-
-/// Given a path to new and old vocabulary files, returns a remapping Tensor of
-///
-/// length `num_new_vocab`, where `remapping[i]` contains the row number in the old
-/// vocabulary that corresponds to row `i` in the new vocabulary (starting at line
-/// `new_vocab_offset` and up to `num_new_vocab` entities), or `-1` if entry `i`
-/// in the new vocabulary is not in the old vocabulary.  The old vocabulary is
-/// constrained to the first `old_vocab_size` entries if `old_vocab_size` is not the
-/// default value of -1.
-///
-/// `num_vocab_offset` enables
-/// use in the partitioned variable case, and should generally be set through
-/// examining partitioning info.  The format of the files should be a text file,
-/// with each line containing a single entity within the vocabulary.
-///
-/// For example, with `new_vocab_file` a text file containing each of the following
-/// elements on a single line: `[f0, f1, f2, f3]`, old_vocab_file = [f1, f0, f3],
-/// `num_new_vocab = 3, new_vocab_offset = 1`, the returned remapping would be
-/// `[0, -1, 2]`.
-///
-/// The op also returns a count of how many entries in the new vocabulary
-/// were present in the old vocabulary, which is used to calculate the number of
-/// values to initialize in a weight matrix remapping
-///
-/// This functionality can be used to remap both row vocabularies (typically,
-/// features) and column vocabularies (typically, classes) from TensorFlow
-/// checkpoints.  Note that the partitioning logic relies on contiguous vocabularies
-/// corresponding to div-partitioned variables.  Moreover, the underlying remapping
-/// uses an IndexTable (as opposed to an inexact CuckooTable), so client code should
-/// use the corresponding index_table_from_file() as the FeatureColumn framework
-/// does (as opposed to tf.feature_to_id(), which uses a CuckooTable).
-///
-/// - Parameters:
-///   - new_vocab_file: Path to the new vocab file.
-///   - old_vocab_file: Path to the old vocab file.
-///
-/// - Attrs:
-///   - new_vocab_offset: How many entries into the new vocab file to start reading.
-///   - num_new_vocab: Number of entries in the new vocab file to remap.
-///   - old_vocab_size: Number of entries in the old vocab file to consider.  If -1,
-///     use the entire old vocabulary.
-///
-/// - Outputs:
-///   - remapping: A Tensor of length num_new_vocab where the element at index i
-///     is equal to the old ID that maps to the new ID i.  This element is -1 for any
-///     new ID that is not found in the old vocabulary.
-///   - num_present: Number of new vocab entries found in old vocab.
-@inlinable
-public static func generateVocabRemapping(
-  newVocabFile: StringTensor,
-  oldVocabFile: StringTensor,
-  newVocabOffset: Int64,
-  numNewVocab: Int64,
-  oldVocabSize: Int64 = -1
-) -> (remapping: Tensor<Int64>, numPresent: Tensor<Int32>) {
-  let op = TFE_Op("GenerateVocabRemapping")
-  op.setAttr("new_vocab_offset", newVocabOffset)
-  op.setAttr("num_new_vocab", numNewVocab)
-  op.setAttr("old_vocab_size", oldVocabSize)
-  let _ = op.addInput(newVocabFile)
-  let _ = op.addInput(oldVocabFile)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Creates a dataset that invokes a function to generate elements.
-@inlinable
-public static func generatorDataset<
-    InitfuncIn: TensorGroup,
-    InitfuncOut: TensorGroup,
-    NextfuncIn: TensorGroup,
-    NextfuncOut: TensorGroup,
-    FinalizefuncIn: TensorGroup,
-    FinalizefuncOut: TensorGroup,
-    TinitFuncArgs: TensorArrayProtocol,
-    TnextFuncArgs: TensorArrayProtocol,
-    TfinalizeFuncArgs: TensorArrayProtocol
->(
-  initFuncOtherArgs: TinitFuncArgs,
-  nextFuncOtherArgs: TnextFuncArgs,
-  finalizeFuncOtherArgs: TfinalizeFuncArgs,
-  initFunc: (InitfuncIn) -> InitfuncOut,
-  nextFunc: (NextfuncIn) -> NextfuncOut,
-  finalizeFunc: (FinalizefuncIn) -> FinalizefuncOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("GeneratorDataset")
-  op.setAttr("init_func", initFunc)
-  op.setAttr("next_func", nextFunc)
-  op.setAttr("finalize_func", finalizeFunc)
-  op.setAttr("Tinit_func_args", initFuncOtherArgs._typeList)
-  op.setAttr("Tnext_func_args", nextFuncOtherArgs._typeList)
-  op.setAttr("Tfinalize_func_args", finalizeFuncOtherArgs._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInputList(initFuncOtherArgs)
-  let _ = op.addInputList(nextFuncOtherArgs)
-  let _ = op.addInputList(finalizeFuncOtherArgs)
-  return op.execute(Int(1))
-}
-
-/// Store the input tensor in the state of the current session.
-///
-/// - Parameter value: The tensor to be stored.
-///
-/// - Output handle: The handle for the tensor stored in the session state, represented
-///   as a string.
-@inlinable
-public static func getSessionHandle<T: TensorFlowScalar>(
-  value: Tensor<T>
-) -> StringTensor {
-  let op = TFE_Op("GetSessionHandle")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(value)
-  return op.execute(Int(1))
-}
-
-/// Store the input tensor in the state of the current session.
-///
-/// - Parameter value: The tensor to be stored.
-///
-/// - Output handle: The handle for the tensor stored in the session state, represented
-///   as a ResourceHandle object.
-@inlinable
-public static func getSessionHandleV2<T: TensorFlowScalar>(
-  value: Tensor<T>
-) -> ResourceHandle {
-  let op = TFE_Op("GetSessionHandleV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(value)
-  return op.execute(Int(1))
-}
-
-/// Get the value of the tensor specified by its handle.
-///
-/// - Parameter handle: The handle for a tensor stored in the session state.
-///
-/// - Attr dtype: The type of the output value.
-///
-/// - Output value: The tensor for the given handle.
-@inlinable
-public static func getSessionTensor<Dtype: TensorFlowScalar>(
-  handle: StringTensor
-) -> Tensor<Dtype> {
-  let op = TFE_Op("GetSessionTensor")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(handle)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func graphDefVersion(
-) -> Tensor<Int32> {
-  let op = TFE_Op("GraphDefVersion")
-  
-  return op.execute(Int(1))
-}
-
-/// Returns the truth value of (x > y) element-wise.
-///
-/// *NOTE*: `Greater` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func greater<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<Bool> {
-  let op = TFE_Op("Greater")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns the truth value of (x >= y) element-wise.
-///
-/// *NOTE*: `GreaterEqual` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func greaterEqual<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<Bool> {
-  let op = TFE_Op("GreaterEqual")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Gives a guarantee to the TF runtime that the input tensor is a constant.
-///
-/// The runtime is then free to make optimizations based on this.
-///
-/// Only accepts value typed tensors as inputs and rejects resource variable handles
-/// as input.
-///
-/// Returns the input tensor without modification.
-@inlinable
-public static func guaranteeConst<T: TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("GuaranteeConst")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Convert one or more images from HSV to RGB.
-///
-/// Outputs a tensor of the same shape as the `images` tensor, containing the RGB
-/// value of the pixels. The output is only well defined if the value in `images`
-/// are in `[0,1]`.
-///
-/// See `rgb_to_hsv` for a description of the HSV encoding.
-///
-/// - Parameter images: 1-D or higher rank. HSV data to convert. Last dimension must be size 3.
-///
-/// - Output output: `images` converted to RGB.
-@inlinable
-public static func hSVToRGB<T: FloatingPoint & TensorFlowScalar>(
-  images: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("HSVToRGB")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(images)
-  return op.execute(Int(1))
-}
-
-/// Creates a non-initialized hash table.
-///
-/// This op creates a hash table, specifying the type of its keys and values.
-/// Before using the table you will have to initialize it.  After initialization the
-/// table will be immutable.
-///
-/// - Attrs:
-///   - container: If non-empty, this table is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this table is shared under the given name across
-///     multiple sessions.
-///   - use_node_name_sharing: If true and shared_name is empty, the table is shared
-///     using the node name.
-///   - key_dtype: Type of the table keys.
-///   - value_dtype: Type of the table values.
-///
-/// - Output table_handle: Handle to a table.
-@inlinable
-public static func hashTableV2(
-  container: String,
-  sharedName: String,
-  useNodeNameSharing: Bool = false,
-  keyDtype: TensorDataType,
-  valueDtype: TensorDataType
-) -> ResourceHandle {
-  let op = TFE_Op("HashTableV2")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("use_node_name_sharing", useNodeNameSharing)
-  op.setAttr("key_dtype", keyDtype)
-  op.setAttr("value_dtype", valueDtype)
-  return op.execute(Int(1))
-}
-
-/// Return histogram of values.
-///
-/// Given the tensor `values`, this operation returns a rank 1 histogram counting
-/// the number of entries in `values` that fall into every bin.  The bins are
-/// equal width and determined by the arguments `value_range` and `nbins`.
-///
-/// ```python
-/// # Bins will be:  (-inf, 1), [1, 2), [2, 3), [3, 4), [4, inf)
-/// nbins = 5
-/// value_range = [0.0, 5.0]
-/// new_values = [-1.0, 0.0, 1.5, 2.0, 5.0, 15]
-///
-/// with tf.get_default_session() as sess:
-///   hist = tf.histogram_fixed_width(new_values, value_range, nbins=5)
-///   variables.global_variables_initializer().run()
-///   sess.run(hist) => [2, 1, 1, 0, 2]
-/// ```
-///
-/// - Parameters:
-///   - values: Numeric `Tensor`.
-///   - value_range: Shape [2] `Tensor` of same `dtype` as `values`.
-///     values <= value_range[0] will be mapped to hist[0],
-///     values >= value_range[1] will be mapped to hist[-1].
-///   - nbins: Scalar `int32 Tensor`.  Number of histogram bins.
-///
-/// - Output out: A 1-D `Tensor` holding histogram of values.
-@inlinable
-public static func histogramFixedWidth<
-    T: Numeric & TensorFlowScalar,
-    Dtype: BinaryInteger & TensorFlowScalar
->(
-  _ values: Tensor<T>,
-  valueRange: Tensor<T>,
-  nbins: Tensor<Int32>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("HistogramFixedWidth")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(values)
-  let _ = op.addInput(valueRange)
-  let _ = op.addInput(nbins)
-  return op.execute(Int(1))
-}
-
-/// Outputs a `Summary` protocol buffer with a histogram.
-///
-/// The generated
-/// [`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto)
-/// has one summary value containing a histogram for `values`.
-///
-/// This op reports an `InvalidArgument` error if any value is not finite.
-///
-/// - Parameters:
-///   - tag: Scalar.  Tag to use for the `Summary.Value`.
-///   - values: Any shape. Values to use to build the histogram.
-///
-/// - Output summary: Scalar. Serialized `Summary` protocol buffer.
-@inlinable
-public static func histogramSummary<T: Numeric & TensorFlowScalar>(
-  tag: StringTensor,
-  _ values: Tensor<T>
-) -> StringTensor {
-  let op = TFE_Op("HistogramSummary")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(tag)
-  let _ = op.addInput(values)
-  return op.execute(Int(1))
-}
-
-/// Inverse fast Fourier transform.
-///
-/// Computes the inverse 1-dimensional discrete Fourier transform over the
-/// inner-most dimension of `input`.
-///
-/// - Parameter input: A complex tensor.
-///
-/// - Output output: A complex tensor of the same shape as `input`. The inner-most
-///     dimension of `input` is replaced with its inverse 1D Fourier transform.
-///
-///   @compatibility(numpy)
-///   Equivalent to np.fft.ifft
-///   @end_compatibility
-@inlinable
-public static func iFFT<Tcomplex: TensorFlowScalar>(
-  _ input: Tensor<Tcomplex>
-) -> Tensor<Tcomplex> {
-  let op = TFE_Op("IFFT")
-  op.setAttr("Tcomplex", Tcomplex.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Inverse 2D fast Fourier transform.
-///
-/// Computes the inverse 2-dimensional discrete Fourier transform over the
-/// inner-most 2 dimensions of `input`.
-///
-/// - Parameter input: A complex tensor.
-///
-/// - Output output: A complex tensor of the same shape as `input`. The inner-most 2
-///     dimensions of `input` are replaced with their inverse 2D Fourier transform.
-///
-///   @compatibility(numpy)
-///   Equivalent to np.fft.ifft2
-///   @end_compatibility
-@inlinable
-public static func iFFT2D<Tcomplex: TensorFlowScalar>(
-  _ input: Tensor<Tcomplex>
-) -> Tensor<Tcomplex> {
-  let op = TFE_Op("IFFT2D")
-  op.setAttr("Tcomplex", Tcomplex.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Inverse 3D fast Fourier transform.
-///
-/// Computes the inverse 3-dimensional discrete Fourier transform over the
-/// inner-most 3 dimensions of `input`.
-///
-/// - Parameter input: A complex64 tensor.
-///
-/// - Output output: A complex64 tensor of the same shape as `input`. The inner-most 3
-///     dimensions of `input` are replaced with their inverse 3D Fourier transform.
-///
-///   @compatibility(numpy)
-///   Equivalent to np.fft.ifftn with 3 dimensions.
-///   @end_compatibility
-@inlinable
-public static func iFFT3D<Tcomplex: TensorFlowScalar>(
-  _ input: Tensor<Tcomplex>
-) -> Tensor<Tcomplex> {
-  let op = TFE_Op("IFFT3D")
-  op.setAttr("Tcomplex", Tcomplex.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Return a tensor with the same shape and contents as the input tensor or value.
-@inlinable
-public static func identity<T: TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Identity")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Returns a list of tensors with the same shapes and contents as the input
-///
-/// tensors.
-///
-/// This op can be used to override the gradient for complicated functions. For
-/// example, suppose y = f(x) and we wish to apply a custom function g for backprop
-/// such that dx = g(dy). In Python,
-///
-/// ```python
-/// with tf.get_default_graph().gradient_override_map(
-///     {'IdentityN': 'OverrideGradientWithG'}):
-///   y, _ = identity_n([f(x), x])
-///
-/// @tf.RegisterGradient('OverrideGradientWithG')
-/// def ApplyG(op, dy, _):
-///   return [None, g(dy)]  # Do not backprop to f(x).
-/// ```
-@inlinable
-public static func identityN<T: TensorArrayProtocol>(
-  _ input: T
-) -> T {
-  let op = TFE_Op("IdentityN")
-  op.setAttr("T", input._typeList)
-  let _ = op.addInputList(input)
-  return op.execute(Int(input._typeList.count))
-}
-
-/// A Reader that outputs the queued work as both the key and value.
-///
-/// To use, enqueue strings in a Queue.  ReaderRead will take the front
-/// work string and output (work, work).
-///
-/// - Attrs:
-///   - container: If non-empty, this reader is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this reader is named in the given bucket
-///     with this shared_name. Otherwise, the node name is used instead.
-///
-/// - Output reader_handle: The handle to reference the Reader.
-@inlinable
-public static func identityReaderV2(
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("IdentityReaderV2")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// output = cond ? then_branch(input) : else_branch(input)
-///
-/// - Parameters:
-///   - cond:       A Tensor. If the tensor is a scalar of non-boolean type, the
-///           scalar is converted to a boolean according to the
-///           following rule: if the scalar is a numerical value, non-zero means
-///           `True` and zero means False; if the scalar is a string, non-empty
-///           means `True` and empty means `False`. If the tensor is not a scalar,
-///           being empty means False and being non-empty means True.
-///   - input: A list of input tensors.
-///
-/// - Attrs:
-///   - Tin: A list of input types.
-///   - Tout: A list of output types.
-///   - then_branch:       A function that takes 'inputs' and returns a list of tensors, whose
-///           types are the same as what else_branch returns.
-///   - else_branch:     A function that takes 'inputs' and returns a list of tensors, whose
-///         types are the same as what then_branch returns.
-///
-/// - Output output: A list of return values.
-@inlinable
-public static func if_<
-    Tcond: TensorFlowScalar,
-    Tin: TensorArrayProtocol,
-    Tout: TensorGroup,
-    ThenbranchIn: TensorGroup,
-    ThenbranchOut: TensorGroup,
-    ElsebranchIn: TensorGroup,
-    ElsebranchOut: TensorGroup
->(
-  cond: Tensor<Tcond>,
-  _ input: Tin,
-  thenBranch: (ThenbranchIn) -> ThenbranchOut,
-  elseBranch: (ElsebranchIn) -> ElsebranchOut,
-  outputShapes: [TensorShape?]
-) -> Tout {
-  let op = TFE_Op("If")
-  op.setAttr("Tcond", Tcond.tensorFlowDataType)
-  op.setAttr("Tin", input._typeList)
-  op.setAttr("Tout", Tout._typeList)
-  op.setAttr("then_branch", thenBranch)
-  op.setAttr("else_branch", elseBranch)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(cond)
-  let _ = op.addInputList(input)
-  return op.execute(Int(Tout._typeList.count))
-}
-
-/// Compute the lower regularized incomplete Gamma function `P(a, x)`.
-///
-/// The lower regularized incomplete Gamma function is defined as:
-///
-///
-/// \\(P(a, x) = gamma(a, x) / Gamma(a) = 1 - Q(a, x)\\)
-///
-/// where
-///
-/// \\(gamma(a, x) = \\int_{0}^{x} t^{a-1} exp(-t) dt\\)
-///
-/// is the lower incomplete Gamma function.
-///
-/// Note, above `Q(a, x)` (`Igammac`) is the upper regularized complete
-/// Gamma function.
-@inlinable
-public static func igamma<T: FloatingPoint & TensorFlowScalar>(
-  _ a: Tensor<T>,
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Igamma")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient of `igamma(a, x)` wrt `a`.
-@inlinable
-public static func igammaGradA<T: FloatingPoint & TensorFlowScalar>(
-  _ a: Tensor<T>,
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("IgammaGradA")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Compute the upper regularized incomplete Gamma function `Q(a, x)`.
-///
-/// The upper regularized incomplete Gamma function is defined as:
-///
-/// \\(Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)\\)
-///
-/// where
-///
-/// \\(Gamma(a, x) = int_{x}^{\infty} t^{a-1} exp(-t) dt\\)
-///
-/// is the upper incomplete Gama function.
-///
-/// Note, above `P(a, x)` (`Igamma`) is the lower regularized complete
-/// Gamma function.
-@inlinable
-public static func igammac<T: FloatingPoint & TensorFlowScalar>(
-  _ a: Tensor<T>,
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Igammac")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns the imaginary part of a complex number.
-///
-/// Given a tensor `input` of complex numbers, this operation returns a tensor of
-/// type `float` that is the imaginary part of each element in `input`. All
-/// elements in `input` must be complex numbers of the form \\(a + bj\\), where *a*
-/// is the real part and *b* is the imaginary part returned by this operation.
-///
-/// For example:
-///
-/// ```
-/// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
-/// tf.imag(input) ==> [4.75, 5.75]
-/// ```
-@inlinable
-public static func imag<
-    T: TensorFlowScalar,
-    Tout: FloatingPoint & TensorFlowScalar
->(
-  _ input: Tensor<T>
-) -> Tensor<Tout> {
-  let op = TFE_Op("Imag")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tout", Tout.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Returns immutable tensor from memory region.
-///
-/// The current implementation memmaps the tensor from a file.
-///
-/// - Attrs:
-///   - dtype: Type of the returned tensor.
-///   - shape: Shape of the returned tensor.
-///   - memory_region_name: Name of readonly memory region used by the tensor, see
-///     NewReadOnlyMemoryRegionFromFile in tensorflow::Env.
-@inlinable
-public static func immutableConst<Dtype: TensorFlowScalar>(
-  shape: TensorShape?,
-  memoryRegionName: String
-) -> Tensor<Dtype> {
-  let op = TFE_Op("ImmutableConst")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape", shape)
-  op.setAttr("memory_region_name", memoryRegionName)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func importEvent(
-  writer: ResourceHandle,
-  event: StringTensor
-) {
-  let op = TFE_Op("ImportEvent")
-  let _ = op.addInput(writer)
-  let _ = op.addInput(event)
-  op.execute()
-}
-
-@inlinable
-public static func inPolymorphicTwice<T: TensorFlowScalar>(
-  _ a: [Tensor<T>],
-  _ b: [Tensor<T>]
-) {
-  let op = TFE_Op("InPolymorphicTwice")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("N", a.count)
-  op.setAttr("M", b.count)
-  let _ = op.addInputList(a)
-  let _ = op.addInputList(b)
-  op.execute()
-}
-
-/// Says whether the targets are in the top `K` predictions.
-///
-/// This outputs a `batch_size` bool array, an entry `out[i]` is `true` if the
-/// prediction for the target class is among the top `k` predictions among
-/// all predictions for example `i`. Note that the behavior of `InTopK` differs
-/// from the `TopK` op in its handling of ties; if multiple classes have the
-/// same prediction value and straddle the top-`k` boundary, all of those
-/// classes are considered to be in the top `k`.
-///
-/// More formally, let
-///
-///   \\(predictions_i\\) be the predictions for all classes for example `i`,
-///   \\(targets_i\\) be the target class for example `i`,
-///   \\(out_i\\) be the output for example `i`,
-///
-/// $$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
-///
-/// - Parameters:
-///   - predictions: A `batch_size` x `classes` tensor.
-///   - targets: A `batch_size` vector of class ids.
-///
-/// - Attr k: Number of top elements to look at for computing precision.
-///
-/// - Output precision: Computed Precision at `k` as a `bool Tensor`.
-@inlinable
-public static func inTopK<T: BinaryInteger & TensorFlowScalar>(
-  predictions: Tensor<Float>,
-  targets: Tensor<T>,
-  k: Int64
-) -> Tensor<Bool> {
-  let op = TFE_Op("InTopK")
-  op.setAttr("k", k)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(predictions)
-  let _ = op.addInput(targets)
-  return op.execute(Int(1))
-}
-
-/// Says whether the targets are in the top `K` predictions.
-///
-/// This outputs a `batch_size` bool array, an entry `out[i]` is `true` if the
-/// prediction for the target class is among the top `k` predictions among
-/// all predictions for example `i`. Note that the behavior of `InTopK` differs
-/// from the `TopK` op in its handling of ties; if multiple classes have the
-/// same prediction value and straddle the top-`k` boundary, all of those
-/// classes are considered to be in the top `k`.
-///
-/// More formally, let
-///
-///   \\(predictions_i\\) be the predictions for all classes for example `i`,
-///   \\(targets_i\\) be the target class for example `i`,
-///   \\(out_i\\) be the output for example `i`,
-///
-/// $$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
-///
-/// - Parameters:
-///   - predictions: A `batch_size` x `classes` tensor.
-///   - targets: A `batch_size` vector of class ids.
-///   - k: Number of top elements to look at for computing precision.
-///
-/// - Output precision: Computed precision at `k` as a `bool Tensor`.
-@inlinable
-public static func inTopKV2<T: BinaryInteger & TensorFlowScalar>(
-  predictions: Tensor<Float>,
-  targets: Tensor<T>,
-  k: Tensor<T>
-) -> Tensor<Bool> {
-  let op = TFE_Op("InTopKV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(predictions)
-  let _ = op.addInput(targets)
-  let _ = op.addInput(k)
-  return op.execute(Int(1))
-}
-
-/// A placeholder op for a value that will be fed into the computation.
-///
-/// - Attrs:
-///   - dtype: The type of elements in the tensor.
-///   - shape: The shape of the tensor.
-///
-/// - Output output: A tensor that will be provided using the infeed mechanism.
-@inlinable
-public static func infeedDequeue<Dtype: TensorFlowScalar>(
-  shape: TensorShape?
-) -> Tensor<Dtype> {
-  let op = TFE_Op("InfeedDequeue")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape", shape)
-  return op.execute(Int(1))
-}
-
-/// Fetches multiple values from infeed as an XLA tuple.
-///
-/// - Attrs:
-///   - dtypes: The element types of each element in `outputs`.
-///   - shapes: The shapes of each tensor in `outputs`.
-///
-/// - Output outputs: A list of tensors that will be provided using the infeed mechanism.
-@inlinable
-public static func infeedDequeueTuple<Dtypes: TensorGroup>(
-  shapes: [TensorShape?]
-) -> Dtypes {
-  let op = TFE_Op("InfeedDequeueTuple")
-  op.setAttr("dtypes", Dtypes._typeList)
-  op.setAttr("shapes", shapes)
-  return op.execute(Int(Dtypes._typeList.count))
-}
-
-/// An op which feeds a single Tensor value into the computation.
-///
-/// - Parameter input: A tensor that will be provided using the infeed mechanism.
-///
-/// - Attrs:
-///   - dtype: The type of elements in the tensor.
-///   - shape: The shape of the tensor.
-///   - layout: A vector holding the requested layout in minor-to-major sequence.
-///     If a layout attribute is passed, but its values are all -1, the layout will
-///     be computed by the infeed operation.
-///   - device_ordinal: The TPU device to use. This should be -1 when the Op
-///     is running on a TPU device, and >= 0 when the Op is running on the CPU
-///     device.
-@inlinable
-public static func infeedEnqueue<Dtype: TensorFlowScalar>(
-  _ input: Tensor<Dtype>,
-  shape: TensorShape?,
-  layout: [Int32],
-  deviceOrdinal: Int64 = -1
-) {
-  let op = TFE_Op("InfeedEnqueue")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape", shape)
-  op.setAttr("layout", layout)
-  op.setAttr("device_ordinal", deviceOrdinal)
-  let _ = op.addInput(input)
-  op.execute()
-}
-
-/// An op which enqueues prelinearized buffer into TPU infeed.
-///
-/// - Parameter input: A variant tensor representing linearized output.
-///
-/// - Attr device_ordinal: The TPU device to use. This should be -1 when the Op is running on a TPU device
-///   and = 0 when the Op is running on the CPU device.
-@inlinable
-public static func infeedEnqueuePrelinearizedBuffer(
-  _ input: VariantHandle,
-  deviceOrdinal: Int64 = -1
-) {
-  let op = TFE_Op("InfeedEnqueuePrelinearizedBuffer")
-  op.setAttr("device_ordinal", deviceOrdinal)
-  let _ = op.addInput(input)
-  op.execute()
-}
-
-/// Feeds multiple Tensor values into the computation as an XLA tuple.
-///
-/// - Parameter inputs: A list of tensors that will be provided using the infeed mechanism.
-///
-/// - Attrs:
-///   - dtypes: The element types of each element in `inputs`.
-///   - shapes: The shapes of each tensor in `inputs`.
-///   - layouts: A vector holding the requested layout in minor-to-major sequence for
-///     all the tuple shapes, in the order the shapes appear in the "shapes" input.
-///     The layout elements for a sub-shape can be set to -1, in which case the
-///     corresponding layout will be computed by the infeed operation.
-///   - device_ordinal: The TPU device to use. This should be -1 when the Op
-///     is running on a TPU device, and >= 0 when the Op is running on the CPU
-///     device.
-@inlinable
-public static func infeedEnqueueTuple<Dtypes: TensorArrayProtocol>(
-  inputs: Dtypes,
-  shapes: [TensorShape?],
-  layouts: [Int32],
-  deviceOrdinal: Int64 = -1
-) {
-  let op = TFE_Op("InfeedEnqueueTuple")
-  op.setAttr("dtypes", inputs._typeList)
-  op.setAttr("shapes", shapes)
-  op.setAttr("layouts", layouts)
-  op.setAttr("device_ordinal", deviceOrdinal)
-  let _ = op.addInputList(inputs)
-  op.execute()
-}
-
-/// Initializes a table from a text file.
-///
-/// It inserts one key-value pair into the table for each line of the file.
-/// The key and value is extracted from the whole line content, elements from the
-/// split line based on `delimiter` or the line number (starting from zero).
-/// Where to extract the key and value from a line is specified by `key_index` and
-/// `value_index`.
-///
-/// - A value of -1 means use the line number(starting from zero), expects `int64`.
-/// - A value of -2 means use the whole line content, expects `string`.
-/// - A value >= 0 means use the index (starting at zero) of the split line based
-///   on `delimiter`.
-///
-/// - Parameters:
-///   - table_handle: Handle to a table which will be initialized.
-///   - filename: Filename of a vocabulary text file.
-///
-/// - Attrs:
-///   - key_index: Column index in a line to get the table `key` values from.
-///   - value_index: Column index that represents information of a line to get the table
-///     `value` values from.
-///   - vocab_size: Number of elements of the file, use -1 if unknown.
-///   - delimiter: Delimiter to separate fields in a line.
-@inlinable
-public static func initializeTableFromTextFileV2(
-  tableHandle: ResourceHandle,
-  filename: StringTensor,
-  keyIndex: Int64,
-  valueIndex: Int64,
-  vocabSize: Int64 = -1,
-  delimiter: String = "\t"
-) {
-  let op = TFE_Op("InitializeTableFromTextFileV2")
-  op.setAttr("key_index", keyIndex)
-  op.setAttr("value_index", valueIndex)
-  op.setAttr("vocab_size", vocabSize)
-  op.setAttr("delimiter", delimiter)
-  let _ = op.addInput(tableHandle)
-  let _ = op.addInput(filename)
-  op.execute()
-}
-
-/// Table initializer that takes two tensors for keys and values respectively.
-///
-/// - Parameters:
-///   - table_handle: Handle to a table which will be initialized.
-///   - keys: Keys of type Tkey.
-///   - values: Values of type Tval.
-@inlinable
-public static func initializeTableV2<
-    Tkey: TensorFlowScalar,
-    Tval: TensorFlowScalar
->(
-  tableHandle: ResourceHandle,
-  keys: Tensor<Tkey>,
-  _ values: Tensor<Tval>
-) {
-  let op = TFE_Op("InitializeTableV2")
-  op.setAttr("Tkey", Tkey.tensorFlowDataType)
-  op.setAttr("Tval", Tval.tensorFlowDataType)
-  let _ = op.addInput(tableHandle)
-  let _ = op.addInput(keys)
-  let _ = op.addInput(values)
-  op.execute()
-}
-
-///     Adds v into specified rows of x.
-///
-///     Computes y = x; y[i, :] += v; return y.
-///
-/// - Parameters:
-///   - x: A `Tensor` of type T.
-///   - i: A vector. Indices into the left-most dimension of `x`.
-///   - v: A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
-///
-/// - Output y: A `Tensor` of type T. An alias of `x`. The content of `y` is undefined if there are duplicates in `i`.
-@inlinable
-public static func inplaceAdd<T: TensorFlowScalar>(
-  _ x: Tensor<T>,
-  i: Tensor<Int32>,
-  v: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("InplaceAdd")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(i)
-  let _ = op.addInput(v)
-  return op.execute(Int(1))
-}
-
-///     Subtracts `v` into specified rows of `x`.
-///
-///     Computes y = x; y[i, :] -= v; return y.
-///
-/// - Parameters:
-///   - x: A `Tensor` of type T.
-///   - i: A vector. Indices into the left-most dimension of `x`.
-///   - v: A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
-///
-/// - Output y: A `Tensor` of type T. An alias of `x`. The content of `y` is undefined if there are duplicates in `i`.
-@inlinable
-public static func inplaceSub<T: TensorFlowScalar>(
-  _ x: Tensor<T>,
-  i: Tensor<Int32>,
-  v: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("InplaceSub")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(i)
-  let _ = op.addInput(v)
-  return op.execute(Int(1))
-}
-
-///     Updates specified rows with values in `v`.
-///
-///     Computes `x[i, :] = v; return x`.
-///
-/// - Parameters:
-///   - x: A tensor of type `T`.
-///   - i: A vector. Indices into the left-most dimension of `x`.
-///   - v: A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
-///
-/// - Output y: A `Tensor` of type T. An alias of `x`. The content of `y` is undefined if there are duplicates in `i`.
-@inlinable
-public static func inplaceUpdate<T: TensorFlowScalar>(
-  _ x: Tensor<T>,
-  i: Tensor<Int32>,
-  v: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("InplaceUpdate")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(i)
-  let _ = op.addInput(v)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func int64Output(
-) -> Tensor<Int64> {
-  let op = TFE_Op("Int64Output")
-  
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func intAttr(
-  foo: Int64 = 1
-) -> Tensor<Int64> {
-  let op = TFE_Op("IntAttr")
-  op.setAttr("foo", foo)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func intInput(
-  _ a: Tensor<Int32>
-) {
-  let op = TFE_Op("IntInput")
-  let _ = op.addInput(a)
-  op.execute()
-}
-
-@inlinable
-public static func intInputFloatInput(
-  _ a: Tensor<Int32>,
-  _ b: Tensor<Float>
-) {
-  let op = TFE_Op("IntInputFloatInput")
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  op.execute()
-}
-
-@inlinable
-public static func intInputIntOutput(
-  _ a: Tensor<Int32>
-) -> Tensor<Int32> {
-  let op = TFE_Op("IntInputIntOutput")
-  let _ = op.addInput(a)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func intOutput(
-) -> Tensor<Int32> {
-  let op = TFE_Op("IntOutput")
-  
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func intOutputFloatOutput(
-) -> (a: Tensor<Int32>, b: Tensor<Float>) {
-  let op = TFE_Op("IntOutputFloatOutput")
-  
-  return op.execute(Int(1), Int(1))
-}
-
-/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
-///
-/// Unlike MapDataset, the `f` in InterleaveDataset is expected to return
-/// a Dataset variant, and InterleaveDataset will flatten successive
-/// results into a single Dataset. Unlike FlatMapDataset,
-/// InterleaveDataset will interleave sequences of up to `block_length`
-/// consecutive elements from `cycle_length` input elements.
-///
-/// - Attr f: A function mapping elements of `input_dataset`, concatenated with
-///   `other_arguments`, to a Dataset variant that contains elements matching
-///   `output_types` and `output_shapes`.
-@inlinable
-public static func interleaveDataset<
-    FIn: TensorGroup,
-    FOut: TensorGroup,
-    Targuments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  otherArguments: Targuments,
-  cycleLength: Tensor<Int64>,
-  blockLength: Tensor<Int64>,
-  f: (FIn) -> FOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("InterleaveDataset")
-  op.setAttr("f", f)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(otherArguments)
-  let _ = op.addInput(cycleLength)
-  let _ = op.addInput(blockLength)
-  return op.execute(Int(1))
-}
-
-/// Computes the reciprocal of x element-wise.
-///
-/// I.e., \\(y = 1 / x\\).
-@inlinable
-public static func inv<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Inv")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient for the inverse of `x` wrt its input.
-///
-/// Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy`
-/// is the corresponding input gradient.
-@inlinable
-public static func invGrad<T: FloatingPoint & TensorFlowScalar>(
-  _ y: Tensor<T>,
-  dy: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("InvGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(y)
-  let _ = op.addInput(dy)
-  return op.execute(Int(1))
-}
-
-/// Flips all bits elementwise.
-///
-/// The result will have exactly those bits set, that are not set in `x`. The
-/// computation is performed on the underlying representation of x.
-@inlinable
-public static func invert<T: BinaryInteger & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Invert")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the inverse permutation of a tensor.
-///
-/// This operation computes the inverse of an index permutation. It takes a 1-D
-/// integer tensor `x`, which represents the indices of a zero-based array, and
-/// swaps each value with its index position. In other words, for an output tensor
-/// `y` and an input tensor `x`, this operation computes the following:
-///
-/// `y[x[i]] = i for i in [0, 1, ..., len(x) - 1]`
-///
-/// The values must include 0. There can be no duplicate values or negative values.
-///
-/// For example:
-///
-/// ```
-/// # tensor `x` is [3, 4, 0, 2, 1]
-/// invert_permutation(x) ==> [2, 4, 3, 0, 1]
-/// ```
-///
-/// - Parameter x: 1-D.
-///
-/// - Output y: 1-D.
-@inlinable
-public static func invertPermutation<T: BinaryInteger & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("InvertPermutation")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Checks whether a tree ensemble has been initialized.
-///
-/// - Parameter tree_ensemble_handle: Handle to the tree ensemble resouce.
-///
-/// - Output is_initialized: output boolean on whether it is initialized or not.
-@inlinable
-public static func isBoostedTreesEnsembleInitialized(
-  treeEnsembleHandle: ResourceHandle
-) -> Tensor<Bool> {
-  let op = TFE_Op("IsBoostedTreesEnsembleInitialized")
-  let _ = op.addInput(treeEnsembleHandle)
-  return op.execute(Int(1))
-}
-
-/// Checks whether a quantile stream has been initialized.
-///
-/// An Op that checks if quantile stream resource is initialized.
-///
-/// - Parameter quantile_stream_resource_handle: resource; The reference to quantile stream resource handle.
-///
-/// - Output is_initialized: bool; True if the resource is initialized, False otherwise.
-@inlinable
-public static func isBoostedTreesQuantileStreamResourceInitialized(
-  quantileStreamResourceHandle: ResourceHandle
-) -> Tensor<Bool> {
-  let op = TFE_Op("IsBoostedTreesQuantileStreamResourceInitialized")
-  let _ = op.addInput(quantileStreamResourceHandle)
-  return op.execute(Int(1))
-}
-
-/// Returns which elements of x are finite.
-///
-/// @compatibility(numpy)
-/// Equivalent to np.isfinite
-/// @end_compatibility
-@inlinable
-public static func isFinite<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<Bool> {
-  let op = TFE_Op("IsFinite")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns which elements of x are Inf.
-///
-/// @compatibility(numpy)
-/// Equivalent to np.isinf
-/// @end_compatibility
-@inlinable
-public static func isInf<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<Bool> {
-  let op = TFE_Op("IsInf")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns which elements of x are NaN.
-///
-/// @compatibility(numpy)
-/// Equivalent to np.isnan
-/// @end_compatibility
-@inlinable
-public static func isNan<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<Bool> {
-  let op = TFE_Op("IsNan")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// A container for an iterator resource.
-///
-/// - Output handle: A handle to the iterator that can be passed to a "MakeIterator"
-///   or "IteratorGetNext" op.
-@inlinable
-public static func iterator(
-  sharedName: String,
-  container: String,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> ResourceHandle {
-  let op = TFE_Op("Iterator")
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("container", container)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  return op.execute(Int(1))
-}
-
-/// Converts the given string representing a handle to an iterator to a resource.
-///
-/// - Parameter string_handle: A string representation of the given handle.
-///
-/// - Attrs:
-///   - output_types: If specified, defines the type of each tuple component in an
-///     element produced by the resulting iterator.
-///   - output_shapes: If specified, defines the shape of each tuple component in an
-///     element produced by the resulting iterator.
-///
-/// - Output resource_handle: A handle to an iterator resource.
-@inlinable
-public static func iteratorFromStringHandle(
-  stringHandle: StringTensor,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> ResourceHandle {
-  let op = TFE_Op("IteratorFromStringHandle")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(stringHandle)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func iteratorFromStringHandleV2(
-  stringHandle: StringTensor,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> ResourceHandle {
-  let op = TFE_Op("IteratorFromStringHandleV2")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(stringHandle)
-  return op.execute(Int(1))
-}
-
-/// Gets the next output from the given iterator .
-@inlinable
-public static func iteratorGetNext<OutputTypes: TensorGroup>(
-  iterator: ResourceHandle,
-  outputShapes: [TensorShape?]
-) -> OutputTypes {
-  let op = TFE_Op("IteratorGetNext")
-  op.setAttr("output_types", OutputTypes._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(iterator)
-  return op.execute(Int(OutputTypes._typeList.count))
-}
-
-/// Gets the next output from the given iterator as an Optional variant.
-@inlinable
-public static func iteratorGetNextAsOptional(
-  iterator: ResourceHandle,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("IteratorGetNextAsOptional")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(iterator)
-  return op.execute(Int(1))
-}
-
-/// Gets the next output from the given iterator.
-///
-/// This operation is a synchronous version IteratorGetNext. It should only be used
-/// in situations where the iterator does not block the calling thread, or where
-/// the calling thread is not a member of the thread pool used to execute parallel
-/// operations (e.g. in eager mode).
-@inlinable
-public static func iteratorGetNextSync<OutputTypes: TensorGroup>(
-  iterator: ResourceHandle,
-  outputShapes: [TensorShape?]
-) -> OutputTypes {
-  let op = TFE_Op("IteratorGetNextSync")
-  op.setAttr("output_types", OutputTypes._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(iterator)
-  return op.execute(Int(OutputTypes._typeList.count))
-}
-
-/// Converts the given `resource_handle` representing an iterator to a string.
-///
-/// - Parameter resource_handle: A handle to an iterator resource.
-///
-/// - Output string_handle: A string representation of the given handle.
-@inlinable
-public static func iteratorToStringHandle(
-  resourceHandle: ResourceHandle
-) -> StringTensor {
-  let op = TFE_Op("IteratorToStringHandle")
-  let _ = op.addInput(resourceHandle)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func iteratorV2(
-  sharedName: String,
-  container: String,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> ResourceHandle {
-  let op = TFE_Op("IteratorV2")
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("container", container)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  return op.execute(Int(1))
-}
-
-/// Returns the index of a data point that should be added to the seed set.
-///
-/// Entries in distances are assumed to be squared distances of candidate points to
-/// the already sampled centers in the seed set. The op constructs one Markov chain
-/// of the k-MC^2 algorithm and returns the index of one candidate point to be added
-/// as an additional cluster center.
-///
-/// - Parameters:
-///   - distances: Vector with squared distances to the closest previously sampled cluster center
-///     for each candidate point.
-///   - seed: Scalar. Seed for initializing the random number generator.
-///
-/// - Output index: Scalar with the index of the sampled point.
-@inlinable
-public static func kMC2ChainInitialization(
-  distances: Tensor<Float>,
-  seed: Tensor<Int64>
-) -> Tensor<Int64> {
-  let op = TFE_Op("KMC2ChainInitialization")
-  let _ = op.addInput(distances)
-  let _ = op.addInput(seed)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func kernelLabel(
-) -> StringTensor {
-  let op = TFE_Op("KernelLabel")
-  
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func kernelLabelRequired(
-  _ input: Tensor<Int32>
-) -> StringTensor {
-  let op = TFE_Op("KernelLabelRequired")
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Selects num_to_sample rows of input using the KMeans++ criterion.
-///
-/// Rows of points are assumed to be input points. One row is selected at random.
-/// Subsequent rows are sampled with probability proportional to the squared L2
-/// distance from the nearest row selected thus far till num_to_sample rows have
-/// been sampled.
-///
-/// - Parameters:
-///   - points: Matrix of shape (n, d). Rows are assumed to be input points.
-///   - num_to_sample: Scalar. The number of rows to sample. This value must not be larger than n.
-///   - seed: Scalar. Seed for initializing the random number generator.
-///   - num_retries_per_sample: Scalar. For each row that is sampled, this parameter
-///     specifies the number of additional points to draw from the current
-///     distribution before selecting the best. If a negative value is specified, a
-///     heuristic is used to sample O(log(num_to_sample)) additional points.
-///
-/// - Output samples: Matrix of shape (num_to_sample, d). The sampled rows.
-@inlinable
-public static func kmeansPlusPlusInitialization(
-  points: Tensor<Float>,
-  numToSample: Tensor<Int64>,
-  seed: Tensor<Int64>,
-  numRetriesPerSample: Tensor<Int64>
-) -> Tensor<Float> {
-  let op = TFE_Op("KmeansPlusPlusInitialization")
-  let _ = op.addInput(points)
-  let _ = op.addInput(numToSample)
-  let _ = op.addInput(seed)
-  let _ = op.addInput(numRetriesPerSample)
-  return op.execute(Int(1))
-}
-
-/// L2 Loss.
-///
-/// Computes half the L2 norm of a tensor without the `sqrt`:
-///
-///     output = sum(t ** 2) / 2
-///
-/// - Parameter t: Typically 2-D, but may have any dimensions.
-///
-/// - Output output: 0-D.
-@inlinable
-public static func l2Loss<T: FloatingPoint & TensorFlowScalar>(
-  t: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("L2Loss")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(t)
-  return op.execute(Int(1))
-}
-
-/// Local Response Normalization.
-///
-/// The 4-D `input` tensor is treated as a 3-D array of 1-D vectors (along the last
-/// dimension), and each vector is normalized independently.  Within a given vector,
-/// each component is divided by the weighted, squared sum of inputs within
-/// `depth_radius`.  In detail,
-///
-///     sqr_sum[a, b, c, d] =
-///         sum(input[a, b, c, d - depth_radius : d + depth_radius + 1] ** 2)
-///     output = input / (bias + alpha * sqr_sum) ** beta
-///
-/// For details, see [Krizhevsky et al., ImageNet classification with deep
-/// convolutional neural networks (NIPS 2012)](http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks).
-///
-/// - Parameter input: 4-D.
-///
-/// - Attrs:
-///   - depth_radius: 0-D.  Half-width of the 1-D normalization window.
-///   - bias: An offset (usually positive to avoid dividing by 0).
-///   - alpha: A scale factor, usually positive.
-///   - beta: An exponent.
-@inlinable
-public static func lRN<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  depthRadius: Int64 = 5,
-  bias: Double = 1,
-  alpha: Double = 1,
-  beta: Double = 0.5
-) -> Tensor<T> {
-  let op = TFE_Op("LRN")
-  op.setAttr("depth_radius", depthRadius)
-  op.setAttr("bias", bias)
-  op.setAttr("alpha", alpha)
-  op.setAttr("beta", beta)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Gradients for Local Response Normalization.
-///
-/// - Parameters:
-///   - input_grads: 4-D with shape `[batch, height, width, channels]`.
-///   - input_image: 4-D with shape `[batch, height, width, channels]`.
-///   - output_image: 4-D with shape `[batch, height, width, channels]`.
-///
-/// - Attrs:
-///   - depth_radius: A depth radius.
-///   - bias: An offset (usually > 0 to avoid dividing by 0).
-///   - alpha: A scale factor, usually positive.
-///   - beta: An exponent.
-///
-/// - Output output: The gradients for LRN.
-@inlinable
-public static func lRNGrad<T: FloatingPoint & TensorFlowScalar>(
-  inputGrads: Tensor<T>,
-  inputImage: Tensor<T>,
-  outputImage: Tensor<T>,
-  depthRadius: Int64 = 5,
-  bias: Double = 1,
-  alpha: Double = 1,
-  beta: Double = 0.5
-) -> Tensor<T> {
-  let op = TFE_Op("LRNGrad")
-  op.setAttr("depth_radius", depthRadius)
-  op.setAttr("bias", bias)
-  op.setAttr("alpha", alpha)
-  op.setAttr("beta", beta)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(inputGrads)
-  let _ = op.addInput(inputImage)
-  let _ = op.addInput(outputImage)
-  return op.execute(Int(1))
-}
-
-/// Computes the LSTM cell forward propagation for 1 time step.
-///
-/// This implementation uses 1 weight matrix and 1 bias vector, and there's an
-/// optional peephole connection.
-///
-/// This kernel op implements the following mathematical equations:
-///
-/// ```python
-/// xh = [x, h_prev]
-/// [i, f, ci, o] = xh * w + b
-/// f = f + forget_bias
-///
-/// if not use_peephole:
-///   wci = wcf = wco = 0
-///
-/// i = sigmoid(cs_prev * wci + i)
-/// f = sigmoid(cs_prev * wcf + f)
-/// ci = tanh(ci)
-///
-/// cs = ci .* i + cs_prev .* f
-/// cs = clip(cs, cell_clip)
-///
-/// o = sigmoid(cs * wco + o)
-/// co = tanh(cs)
-/// h = co .* o
-/// ```
-///
-/// - Parameters:
-///   - x: The input to the LSTM cell, shape (batch_size, num_inputs).
-///   - cs_prev: Value of the cell state at previous time step.
-///   - h_prev: Output of the previous cell at previous time step.
-///   - w: The weight matrix.
-///   - wci: The weight matrix for input gate peephole connection.
-///   - wcf: The weight matrix for forget gate peephole connection.
-///   - wco: The weight matrix for output gate peephole connection.
-///   - b: The bias vector.
-///
-/// - Attrs:
-///   - forget_bias: The forget gate bias.
-///   - cell_clip: Value to clip the 'cs' value to.
-///   - use_peephole: Whether to use peephole weights.
-///
-/// - Outputs:
-///   - i: The input gate.
-///   - cs: The cell state before the tanh.
-///   - f: The forget gate.
-///   - o: The output gate.
-///   - ci: The cell input.
-///   - co: The cell after the tanh.
-///   - h: The output h vector.
-@inlinable
-public static func lSTMBlockCell<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  csPrev: Tensor<T>,
-  hPrev: Tensor<T>,
-  w: Tensor<T>,
-  wci: Tensor<T>,
-  wcf: Tensor<T>,
-  wco: Tensor<T>,
-  _ b: Tensor<T>,
-  forgetBias: Double = 1,
-  cellClip: Double = 3,
-  usePeephole: Bool = false
-) -> (i: Tensor<T>, cs: Tensor<T>, f: Tensor<T>, o: Tensor<T>, ci: Tensor<T>, co: Tensor<T>, h: Tensor<T>) {
-  let op = TFE_Op("LSTMBlockCell")
-  op.setAttr("forget_bias", forgetBias)
-  op.setAttr("cell_clip", cellClip)
-  op.setAttr("use_peephole", usePeephole)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(csPrev)
-  let _ = op.addInput(hPrev)
-  let _ = op.addInput(w)
-  let _ = op.addInput(wci)
-  let _ = op.addInput(wcf)
-  let _ = op.addInput(wco)
-  let _ = op.addInput(b)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Computes the LSTM cell backward propagation for 1 timestep.
-///
-/// This implementation is to be used in conjunction of LSTMBlockCell.
-///
-/// - Parameters:
-///   - x: The input to the LSTM cell, shape (batch_size, num_inputs).
-///   - cs_prev: The previous cell state.
-///   - h_prev: The previous h state.
-///   - w: The weight matrix.
-///   - wci: The weight matrix for input gate peephole connection.
-///   - wcf: The weight matrix for forget gate peephole connection.
-///   - wco: The weight matrix for output gate peephole connection.
-///   - b: The bias vector.
-///   - i: The input gate.
-///   - cs: The cell state before the tanh.
-///   - f: The forget gate.
-///   - o: The output gate.
-///   - ci: The cell input.
-///   - co: The cell after the tanh.
-///   - cs_grad: The current gradient of cs.
-///   - h_grad: The gradient of h vector.
-///
-/// - Attr use_peephole: Whether the cell uses peephole connections.
-///
-/// - Outputs:
-///   - cs_prev_grad: The gradient of cs to be back-propped.
-///   - dicfo: The derivative wrt to [i, cs, f, o].
-///   - wci_grad: The gradient for wci to be back-propped.
-///   - wcf_grad: The gradient for wcf to be back-propped.
-///   - wco_grad: The gradient for wco to be back-propped.
-@inlinable
-public static func lSTMBlockCellGrad<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  csPrev: Tensor<T>,
-  hPrev: Tensor<T>,
-  w: Tensor<T>,
-  wci: Tensor<T>,
-  wcf: Tensor<T>,
-  wco: Tensor<T>,
-  _ b: Tensor<T>,
-  i: Tensor<T>,
-  cs: Tensor<T>,
-  f: Tensor<T>,
-  o: Tensor<T>,
-  ci: Tensor<T>,
-  co: Tensor<T>,
-  csGrad: Tensor<T>,
-  hGrad: Tensor<T>,
-  usePeephole: Bool
-) -> (csPrevGrad: Tensor<T>, dicfo: Tensor<T>, wciGrad: Tensor<T>, wcfGrad: Tensor<T>, wcoGrad: Tensor<T>) {
-  let op = TFE_Op("LSTMBlockCellGrad")
-  op.setAttr("use_peephole", usePeephole)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(csPrev)
-  let _ = op.addInput(hPrev)
-  let _ = op.addInput(w)
-  let _ = op.addInput(wci)
-  let _ = op.addInput(wcf)
-  let _ = op.addInput(wco)
-  let _ = op.addInput(b)
-  let _ = op.addInput(i)
-  let _ = op.addInput(cs)
-  let _ = op.addInput(f)
-  let _ = op.addInput(o)
-  let _ = op.addInput(ci)
-  let _ = op.addInput(co)
-  let _ = op.addInput(csGrad)
-  let _ = op.addInput(hGrad)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Computes rectified linear: `max(features, features * alpha)`.
-@inlinable
-public static func leakyRelu<T: FloatingPoint & TensorFlowScalar>(
-  features: Tensor<T>,
-  alpha: Double = 0.2
-) -> Tensor<T> {
-  let op = TFE_Op("LeakyRelu")
-  op.setAttr("alpha", alpha)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(features)
-  return op.execute(Int(1))
-}
-
-/// Computes rectified linear gradients for a LeakyRelu operation.
-///
-/// - Parameters:
-///   - gradients: The backpropagated gradients to the corresponding LeakyRelu operation.
-///   - features: The features passed as input to the corresponding LeakyRelu operation,
-///     OR the outputs of that operation (both work equivalently).
-///
-/// - Output backprops: `gradients * (features > 0) + alpha * gradients * (featurs <= 0)`.
-@inlinable
-public static func leakyReluGrad<T: FloatingPoint & TensorFlowScalar>(
-  gradients: Tensor<T>,
-  features: Tensor<T>,
-  alpha: Double = 0.2
-) -> Tensor<T> {
-  let op = TFE_Op("LeakyReluGrad")
-  op.setAttr("alpha", alpha)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(gradients)
-  let _ = op.addInput(features)
-  return op.execute(Int(1))
-}
-
-/// Generates labels for candidate sampling with a learned unigram distribution.
-///
-/// See explanations of candidate sampling and the data formats at
-/// go/candidate-sampling.
-///
-/// For each batch, this op picks a single set of sampled candidate labels.
-///
-/// The advantages of sampling candidates per-batch are simplicity and the
-/// possibility of efficient dense matrix multiplication. The disadvantage is that
-/// the sampled candidates must be chosen independently of the context and of the
-/// true labels.
-///
-/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
-///   IDs of the num_true target_classes in the corresponding original label.
-///
-/// - Attrs:
-///   - num_true: Number of true labels per context.
-///   - num_sampled: Number of candidates to randomly sample.
-///   - unique: If unique is true, we sample with rejection, so that all sampled
-///     candidates in a batch are unique. This requires some approximation to
-///     estimate the post-rejection sampling probabilities.
-///   - range_max: The sampler will sample integers from the interval [0, range_max).
-///   - seed: If either seed or seed2 are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: An second seed to avoid seed collision.
-///
-/// - Outputs:
-///   - sampled_candidates: A vector of length num_sampled, in which each element is
-///     the ID of a sampled candidate.
-///   - true_expected_count: A batch_size * num_true matrix, representing
-///     the number of times each candidate is expected to occur in a batch
-///     of sampled candidates. If unique=true, then this is a probability.
-///   - sampled_expected_count: A vector of length num_sampled, for each sampled
-///     candidate representing the number of times the candidate is expected
-///     to occur in a batch of sampled candidates.  If unique=true, then this is a
-///     probability.
-@inlinable
-public static func learnedUnigramCandidateSampler(
-  trueClasses: Tensor<Int64>,
-  numTrue: Int64,
-  numSampled: Int64,
-  unique: Bool,
-  rangeMax: Int64,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
-  let op = TFE_Op("LearnedUnigramCandidateSampler")
-  op.setAttr("num_true", numTrue)
-  op.setAttr("num_sampled", numSampled)
-  op.setAttr("unique", unique)
-  op.setAttr("range_max", rangeMax)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(trueClasses)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Elementwise computes the bitwise left-shift of `x` and `y`.
-///
-/// If `y` is negative, or greater than or equal to the width of `x` in bits the
-/// result is implementation defined.
-@inlinable
-public static func leftShift<T: BinaryInteger & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("LeftShift")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns the truth value of (x < y) element-wise.
-///
-/// *NOTE*: `Less` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func less<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<Bool> {
-  let op = TFE_Op("Less")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns the truth value of (x <= y) element-wise.
-///
-/// *NOTE*: `LessEqual` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func lessEqual<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<Bool> {
-  let op = TFE_Op("LessEqual")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Computes the log of the absolute value of `Gamma(x)` element-wise.
-@inlinable
-public static func lgamma<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Lgamma")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Generates values in an interval.
-///
-/// A sequence of `num` evenly-spaced values are generated beginning at `start`.
-/// If `num > 1`, the values in the sequence increase by `stop - start / num - 1`,
-/// so that the last one is exactly `stop`.
-///
-/// For example:
-///
-/// ```
-/// tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0  11.0  12.0]
-/// ```
-///
-/// - Parameters:
-///   - start: 0-D tensor. First entry in the range.
-///   - stop: 0-D tensor. Last entry in the range.
-///   - num: 0-D tensor. Number of values to generate.
-///
-/// - Output output: 1-D. The generated values.
-@inlinable
-public static func linSpace<
-    T: FloatingPoint & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  start: Tensor<T>,
-  stop: Tensor<T>,
-  num: Tensor<Tidx>
-) -> Tensor<T> {
-  let op = TFE_Op("LinSpace")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(start)
-  let _ = op.addInput(stop)
-  let _ = op.addInput(num)
-  return op.execute(Int(1))
-}
-
-/// Computes the difference between two lists of numbers or strings.
-///
-/// Given a list `x` and a list `y`, this operation returns a list `out` that
-/// represents all values that are in `x` but not in `y`. The returned list `out`
-/// is sorted in the same order that the numbers appear in `x` (duplicates are
-/// preserved). This operation also returns a list `idx` that represents the
-/// position of each `out` element in `x`. In other words:
-///
-/// `out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]`
-///
-/// For example, given this input:
-///
-/// ```
-/// x = [1, 2, 3, 4, 5, 6]
-/// y = [1, 3, 5]
-/// ```
-///
-/// This operation would return:
-///
-/// ```
-/// out ==> [2, 4, 6]
-/// idx ==> [1, 3, 5]
-/// ```
-///
-/// - Parameters:
-///   - x: 1-D. Values to keep.
-///   - y: 1-D. Values to remove.
-///
-/// - Outputs:
-///   - out: 1-D. Values present in `x` but not in `y`.
-///   - idx: 1-D. Positions of `x` values preserved in `out`.
-@inlinable
-public static func listDiff<
-    T: TensorFlowScalar,
-    OutIdx: BinaryInteger & TensorFlowScalar
->(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> (out: Tensor<T>, idx: Tensor<OutIdx>) {
-  let op = TFE_Op("ListDiff")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_idx", OutIdx.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1), Int(1))
-}
-
-@inlinable
-public static func listInput<T: TensorFlowScalar>(
-  _ a: [Tensor<T>]
-) {
-  let op = TFE_Op("ListInput")
-  op.setAttr("N", a.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInputList(a)
-  op.execute()
-}
-
-@inlinable
-public static func listOutput<T: TensorGroup>(
-) -> T {
-  let op = TFE_Op("ListOutput")
-  op.setAttr("T", T._typeList)
-  return op.execute(Int(T._typeList.count))
-}
-
-/// Loads a 2-D (matrix) `Tensor` with name `old_tensor_name` from the checkpoint
-///
-/// at `ckpt_path` and potentially reorders its rows and columns using the
-/// specified remappings.
-///
-/// Most users should use one of the wrapper initializers (such as
-/// `tf.contrib.framework.load_and_remap_matrix_initializer`) instead of this
-/// function directly.
-///
-/// The remappings are 1-D tensors with the following properties:
-///
-/// * `row_remapping` must have exactly `num_rows` entries. Row `i` of the output
-///   matrix will be initialized from the row corresponding to index
-///   `row_remapping[i]` in the old `Tensor` from the checkpoint.
-/// * `col_remapping` must have either 0 entries (indicating that no column
-///   reordering is needed) or `num_cols` entries. If specified, column `j` of the
-///   output matrix will be initialized from the column corresponding to index
-///   `col_remapping[j]` in the old `Tensor` from the checkpoint.
-/// * A value of -1 in either of the remappings signifies a "missing" entry. In that
-///   case, values from the `initializing_values` tensor will be used to fill that
-///   missing row or column. If `row_remapping` has `r` missing entries and
-///   `col_remapping` has `c` missing entries, then the following condition must be
-///   true:
-///
-/// `(r * num_cols) + (c * num_rows) - (r * c) == len(initializing_values)`
-///
-/// The remapping tensors can be generated using the GenerateVocabRemapping op.
-///
-/// As an example, with row_remapping = [1, 0, -1], col_remapping = [0, 2, -1],
-/// initializing_values = [0.5, -0.5, 0.25, -0.25, 42], and w(i, j) representing
-/// the value from row i, column j of the old tensor in the checkpoint, the output
-/// matrix will look like the following:
-///
-/// [[w(1, 0),  w(1, 2),  0.5],
-///  [w(0, 0),  w(0, 2), -0.5],
-///  [0.25,    -0.25,      42]]
-///
-/// - Parameters:
-///   - ckpt_path: Path to the TensorFlow checkpoint (version 2, `TensorBundle`) from
-///     which the old matrix `Tensor` will be loaded.
-///   - old_tensor_name: Name of the 2-D `Tensor` to load from checkpoint.
-///   - row_remapping: An int `Tensor` of row remappings (generally created by
-///     `generate_vocab_remapping`).  Even if no row remapping is needed, this must
-///     still be an index-valued Tensor (e.g. [0, 1, 2, ...]), or a shifted
-///     index-valued `Tensor` (e.g. [8, 9, 10, ...], for partitioned `Variables`).
-///   - col_remapping: An int `Tensor` of column remappings (generally created by
-///     `generate_vocab_remapping`).  May be a size-0 `Tensor` if only row remapping
-///     is to be done (e.g. column ordering is the same).
-///   - initializing_values: A float `Tensor` containing  values to fill in for cells
-///     in the output matrix that are not loaded from the checkpoint. Length must be
-///     exactly the same as the number of missing / new cells.
-///
-/// - Attrs:
-///   - num_rows: Number of rows (length of the 1st dimension) in the output matrix.
-///   - num_cols: Number of columns (length of the 2nd dimension) in the output matrix.
-///   - max_rows_in_memory: The maximum number of rows to load from the checkpoint at
-///     once. If less than or equal to 0, the entire matrix will be loaded into
-///     memory. Setting this arg trades increased disk reads for lower memory usage.
-///
-/// - Output output_matrix: Output matrix containing existing values loaded from the
-///   checkpoint, and with any missing values filled in from initializing_values.
-@inlinable
-public static func loadAndRemapMatrix(
-  ckptPath: StringTensor,
-  oldTensorName: StringTensor,
-  rowRemapping: Tensor<Int64>,
-  colRemapping: Tensor<Int64>,
-  initializingValues: Tensor<Float>,
-  numRows: Int64,
-  numCols: Int64,
-  maxRowsInMemory: Int64 = -1
-) -> Tensor<Float> {
-  let op = TFE_Op("LoadAndRemapMatrix")
-  op.setAttr("num_rows", numRows)
-  op.setAttr("num_cols", numCols)
-  op.setAttr("max_rows_in_memory", maxRowsInMemory)
-  let _ = op.addInput(ckptPath)
-  let _ = op.addInput(oldTensorName)
-  let _ = op.addInput(rowRemapping)
-  let _ = op.addInput(colRemapping)
-  let _ = op.addInput(initializingValues)
-  return op.execute(Int(1))
-}
-
-/// Load ADAM embedding parameters.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the ADAM optimization algorithm.
-///   - momenta: Value of momenta used in the ADAM optimization algorithm.
-///   - velocities: Value of velocities used in the ADAM optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingADAMParameters(
-  parameters: Tensor<Float>,
-  momenta: Tensor<Float>,
-  velocities: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingADAMParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(momenta)
-  let _ = op.addInput(velocities)
-  op.execute()
-}
-
-/// Load ADAM embedding parameters with debug support.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the ADAM optimization algorithm.
-///   - momenta: Value of momenta used in the ADAM optimization algorithm.
-///   - velocities: Value of velocities used in the ADAM optimization algorithm.
-///   - gradient_accumulators: Value of gradient_accumulators used in the ADAM optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingADAMParametersGradAccumDebug(
-  parameters: Tensor<Float>,
-  momenta: Tensor<Float>,
-  velocities: Tensor<Float>,
-  gradientAccumulators: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingADAMParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(momenta)
-  let _ = op.addInput(velocities)
-  let _ = op.addInput(gradientAccumulators)
-  op.execute()
-}
-
-/// Load Adadelta embedding parameters.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the Adadelta optimization algorithm.
-///   - accumulators: Value of accumulators used in the Adadelta optimization algorithm.
-///   - updates: Value of updates used in the Adadelta optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingAdadeltaParameters(
-  parameters: Tensor<Float>,
-  accumulators: Tensor<Float>,
-  updates: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingAdadeltaParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(accumulators)
-  let _ = op.addInput(updates)
-  op.execute()
-}
-
-/// Load Adadelta parameters with debug support.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the Adadelta optimization algorithm.
-///   - accumulators: Value of accumulators used in the Adadelta optimization algorithm.
-///   - updates: Value of updates used in the Adadelta optimization algorithm.
-///   - gradient_accumulators: Value of gradient_accumulators used in the Adadelta optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingAdadeltaParametersGradAccumDebug(
-  parameters: Tensor<Float>,
-  accumulators: Tensor<Float>,
-  updates: Tensor<Float>,
-  gradientAccumulators: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingAdadeltaParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(accumulators)
-  let _ = op.addInput(updates)
-  let _ = op.addInput(gradientAccumulators)
-  op.execute()
-}
-
-/// Load Adagrad embedding parameters.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the Adagrad optimization algorithm.
-///   - accumulators: Value of accumulators used in the Adagrad optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingAdagradParameters(
-  parameters: Tensor<Float>,
-  accumulators: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingAdagradParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(accumulators)
-  op.execute()
-}
-
-/// Load Adagrad embedding parameters with debug support.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the Adagrad optimization algorithm.
-///   - accumulators: Value of accumulators used in the Adagrad optimization algorithm.
-///   - gradient_accumulators: Value of gradient_accumulators used in the Adagrad optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingAdagradParametersGradAccumDebug(
-  parameters: Tensor<Float>,
-  accumulators: Tensor<Float>,
-  gradientAccumulators: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingAdagradParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(accumulators)
-  let _ = op.addInput(gradientAccumulators)
-  op.execute()
-}
-
-/// Load centered RMSProp embedding parameters.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the centered RMSProp optimization algorithm.
-///   - ms: Value of ms used in the centered RMSProp optimization algorithm.
-///   - mom: Value of mom used in the centered RMSProp optimization algorithm.
-///   - mg: Value of mg used in the centered RMSProp optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingCenteredRMSPropParameters(
-  parameters: Tensor<Float>,
-  ms: Tensor<Float>,
-  mom: Tensor<Float>,
-  mg: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingCenteredRMSPropParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(ms)
-  let _ = op.addInput(mom)
-  let _ = op.addInput(mg)
-  op.execute()
-}
-
-/// Load FTRL embedding parameters.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the FTRL optimization algorithm.
-///   - accumulators: Value of accumulators used in the FTRL optimization algorithm.
-///   - linears: Value of linears used in the FTRL optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingFTRLParameters(
-  parameters: Tensor<Float>,
-  accumulators: Tensor<Float>,
-  linears: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingFTRLParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(accumulators)
-  let _ = op.addInput(linears)
-  op.execute()
-}
-
-/// Load FTRL embedding parameters with debug support.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the FTRL optimization algorithm.
-///   - accumulators: Value of accumulators used in the FTRL optimization algorithm.
-///   - linears: Value of linears used in the FTRL optimization algorithm.
-///   - gradient_accumulators: Value of gradient_accumulators used in the FTRL optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingFTRLParametersGradAccumDebug(
-  parameters: Tensor<Float>,
-  accumulators: Tensor<Float>,
-  linears: Tensor<Float>,
-  gradientAccumulators: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingFTRLParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(accumulators)
-  let _ = op.addInput(linears)
-  let _ = op.addInput(gradientAccumulators)
-  op.execute()
-}
-
-/// Load MDL Adagrad Light embedding parameters.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the MDL Adagrad Light optimization algorithm.
-///   - accumulators: Value of accumulators used in the MDL Adagrad Light optimization algorithm.
-///   - weights: Value of weights used in the MDL Adagrad Light optimization algorithm.
-///   - benefits: Value of benefits used in the MDL Adagrad Light optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingMDLAdagradLightParameters(
-  parameters: Tensor<Float>,
-  accumulators: Tensor<Float>,
-  weights: Tensor<Float>,
-  benefits: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingMDLAdagradLightParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(accumulators)
-  let _ = op.addInput(weights)
-  let _ = op.addInput(benefits)
-  op.execute()
-}
-
-/// Load Momentum embedding parameters.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the Momentum optimization algorithm.
-///   - momenta: Value of momenta used in the Momentum optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingMomentumParameters(
-  parameters: Tensor<Float>,
-  momenta: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingMomentumParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(momenta)
-  op.execute()
-}
-
-/// Load Momentum embedding parameters with debug support.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the Momentum optimization algorithm.
-///   - momenta: Value of momenta used in the Momentum optimization algorithm.
-///   - gradient_accumulators: Value of gradient_accumulators used in the Momentum optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingMomentumParametersGradAccumDebug(
-  parameters: Tensor<Float>,
-  momenta: Tensor<Float>,
-  gradientAccumulators: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingMomentumParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(momenta)
-  let _ = op.addInput(gradientAccumulators)
-  op.execute()
-}
-
-/// Load proximal Adagrad embedding parameters.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the proximal Adagrad optimization algorithm.
-///   - accumulators: Value of accumulators used in the proximal Adagrad optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingProximalAdagradParameters(
-  parameters: Tensor<Float>,
-  accumulators: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingProximalAdagradParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(accumulators)
-  op.execute()
-}
-
-/// Load proximal Adagrad embedding parameters with debug support.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the proximal Adagrad optimization algorithm.
-///   - accumulators: Value of accumulators used in the proximal Adagrad optimization algorithm.
-///   - gradient_accumulators: Value of gradient_accumulators used in the proximal Adagrad optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingProximalAdagradParametersGradAccumDebug(
-  parameters: Tensor<Float>,
-  accumulators: Tensor<Float>,
-  gradientAccumulators: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(accumulators)
-  let _ = op.addInput(gradientAccumulators)
-  op.execute()
-}
-
-/// Load RMSProp embedding parameters.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the RMSProp optimization algorithm.
-///   - ms: Value of ms used in the RMSProp optimization algorithm.
-///   - mom: Value of mom used in the RMSProp optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingRMSPropParameters(
-  parameters: Tensor<Float>,
-  ms: Tensor<Float>,
-  mom: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingRMSPropParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(ms)
-  let _ = op.addInput(mom)
-  op.execute()
-}
-
-/// Load RMSProp embedding parameters with debug support.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameters:
-///   - parameters: Value of parameters used in the RMSProp optimization algorithm.
-///   - ms: Value of ms used in the RMSProp optimization algorithm.
-///   - mom: Value of mom used in the RMSProp optimization algorithm.
-///   - gradient_accumulators: Value of gradient_accumulators used in the RMSProp optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingRMSPropParametersGradAccumDebug(
-  parameters: Tensor<Float>,
-  ms: Tensor<Float>,
-  mom: Tensor<Float>,
-  gradientAccumulators: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingRMSPropParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  let _ = op.addInput(ms)
-  let _ = op.addInput(mom)
-  let _ = op.addInput(gradientAccumulators)
-  op.execute()
-}
-
-/// Load SGD embedding parameters.
-///
-/// An op that loads optimization parameters into HBM for embedding. Must be
-/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
-/// embedding table configuration. For example, this op is used to install
-/// parameters that are loaded from a checkpoint before a training loop is
-/// executed.
-///
-/// - Parameter parameters: Value of parameters used in the stochastic gradient descent optimization algorithm.
-@inlinable
-public static func loadTPUEmbeddingStochasticGradientDescentParameters(
-  parameters: Tensor<Float>,
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) {
-  let op = TFE_Op("LoadTPUEmbeddingStochasticGradientDescentParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  let _ = op.addInput(parameters)
-  op.execute()
-}
-
-/// Computes natural logarithm of x element-wise.
-///
-/// I.e., \\(y = \log_e x\\).
-@inlinable
-public static func log<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Log")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes natural logarithm of (1 + x) element-wise.
-///
-/// I.e., \\(y = \log_e (1 + x)\\).
-@inlinable
-public static func log1p<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Log1p")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the sign and the log of the absolute value of the determinant of
-///
-/// one or more square matrices.
-///
-/// The input is a tensor of shape `[N, M, M]` whose inner-most 2 dimensions
-/// form square matrices. The outputs are two tensors containing the signs and
-/// absolute values of the log determinants for all N input submatrices
-/// `[..., :, :]` such that the determinant = sign*exp(log_abs_determinant).
-/// The log_abs_determinant is computed as det(P)*sum(log(diag(LU))) where LU
-/// is the LU decomposition of the input and P is the corresponding
-/// permutation matrix.
-///
-/// - Parameter input: Shape is `[N, M, M]`.
-///
-/// - Outputs:
-///   - sign: The signs of the log determinants of the inputs. Shape is `[N]`.
-///   - log_abs_determinant: The logs of the absolute values of the determinants
-///     of the N input matrices.  Shape is `[N]`.
-@inlinable
-public static func logMatrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> (sign: Tensor<T>, logAbsDeterminant: Tensor<T>) {
-  let op = TFE_Op("LogMatrixDeterminant")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Computes log softmax activations.
-///
-/// For each batch `i` and class `j` we have
-///
-///     logsoftmax[i, j] = logits[i, j] - log(sum(exp(logits[i])))
-///
-/// - Parameter logits: 2-D with shape `[batch_size, num_classes]`.
-///
-/// - Output logsoftmax: Same shape as `logits`.
-@inlinable
-public static func logSoftmax<T: FloatingPoint & TensorFlowScalar>(
-  logits: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("LogSoftmax")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(logits)
-  return op.execute(Int(1))
-}
-
-/// Generates labels for candidate sampling with a log-uniform distribution.
-///
-/// See explanations of candidate sampling and the data formats at
-/// go/candidate-sampling.
-///
-/// For each batch, this op picks a single set of sampled candidate labels.
-///
-/// The advantages of sampling candidates per-batch are simplicity and the
-/// possibility of efficient dense matrix multiplication. The disadvantage is that
-/// the sampled candidates must be chosen independently of the context and of the
-/// true labels.
-///
-/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
-///   IDs of the num_true target_classes in the corresponding original label.
-///
-/// - Attrs:
-///   - num_true: Number of true labels per context.
-///   - num_sampled: Number of candidates to randomly sample.
-///   - unique: If unique is true, we sample with rejection, so that all sampled
-///     candidates in a batch are unique. This requires some approximation to
-///     estimate the post-rejection sampling probabilities.
-///   - range_max: The sampler will sample integers from the interval [0, range_max).
-///   - seed: If either seed or seed2 are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: An second seed to avoid seed collision.
-///
-/// - Outputs:
-///   - sampled_candidates: A vector of length num_sampled, in which each element is
-///     the ID of a sampled candidate.
-///   - true_expected_count: A batch_size * num_true matrix, representing
-///     the number of times each candidate is expected to occur in a batch
-///     of sampled candidates. If unique=true, then this is a probability.
-///   - sampled_expected_count: A vector of length num_sampled, for each sampled
-///     candidate representing the number of times the candidate is expected
-///     to occur in a batch of sampled candidates.  If unique=true, then this is a
-///     probability.
-@inlinable
-public static func logUniformCandidateSampler(
-  trueClasses: Tensor<Int64>,
-  numTrue: Int64,
-  numSampled: Int64,
-  unique: Bool,
-  rangeMax: Int64,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
-  let op = TFE_Op("LogUniformCandidateSampler")
-  op.setAttr("num_true", numTrue)
-  op.setAttr("num_sampled", numSampled)
-  op.setAttr("unique", unique)
-  op.setAttr("range_max", rangeMax)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(trueClasses)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Returns the truth value of x AND y element-wise.
-///
-/// *NOTE*: `LogicalAnd` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func logicalAnd(
-  _ x: Tensor<Bool>,
-  _ y: Tensor<Bool>
-) -> Tensor<Bool> {
-  let op = TFE_Op("LogicalAnd")
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns the truth value of NOT x element-wise.
-@inlinable
-public static func logicalNot(
-  _ x: Tensor<Bool>
-) -> Tensor<Bool> {
-  let op = TFE_Op("LogicalNot")
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns the truth value of x OR y element-wise.
-///
-/// *NOTE*: `LogicalOr` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func logicalOr(
-  _ x: Tensor<Bool>,
-  _ y: Tensor<Bool>
-) -> Tensor<Bool> {
-  let op = TFE_Op("LogicalOr")
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Outputs all keys and values in the table.
-///
-/// - Parameter table_handle: Handle to the table.
-///
-/// - Outputs:
-///   - keys: Vector of all keys present in the table.
-///   - values: Tensor of all values in the table. Indexed in parallel with `keys`.
-@inlinable
-public static func lookupTableExportV2<
-    Tkeys: TensorFlowScalar,
-    Tvalues: TensorFlowScalar
->(
-  tableHandle: ResourceHandle
-) -> (keys: Tensor<Tkeys>, values: Tensor<Tvalues>) {
-  let op = TFE_Op("LookupTableExportV2")
-  op.setAttr("Tkeys", Tkeys.tensorFlowDataType)
-  op.setAttr("Tvalues", Tvalues.tensorFlowDataType)
-  let _ = op.addInput(tableHandle)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Looks up keys in a table, outputs the corresponding values.
-///
-/// The tensor `keys` must of the same type as the keys of the table.
-/// The output `values` is of the type of the table values.
-///
-/// The scalar `default_value` is the value output for keys not present in the
-/// table. It must also be of the same type as the table values.
-///
-/// - Parameters:
-///   - table_handle: Handle to the table.
-///   - keys: Any shape.  Keys to look up.
-///
-/// - Output values: Same shape as `keys`.  Values found in the table, or `default_values`
-///   for missing keys.
-@inlinable
-public static func lookupTableFindV2<
-    Tin: TensorFlowScalar,
-    Tout: TensorFlowScalar
->(
-  tableHandle: ResourceHandle,
-  keys: Tensor<Tin>,
-  defaultValue: Tensor<Tout>
-) -> Tensor<Tout> {
-  let op = TFE_Op("LookupTableFindV2")
-  op.setAttr("Tin", Tin.tensorFlowDataType)
-  op.setAttr("Tout", Tout.tensorFlowDataType)
-  let _ = op.addInput(tableHandle)
-  let _ = op.addInput(keys)
-  let _ = op.addInput(defaultValue)
-  return op.execute(Int(1))
-}
-
-/// Replaces the contents of the table with the specified keys and values.
-///
-/// The tensor `keys` must be of the same type as the keys of the table.
-/// The tensor `values` must be of the type of the table values.
-///
-/// - Parameters:
-///   - table_handle: Handle to the table.
-///   - keys: Any shape.  Keys to look up.
-///   - values: Values to associate with keys.
-@inlinable
-public static func lookupTableImportV2<
-    Tin: TensorFlowScalar,
-    Tout: TensorFlowScalar
->(
-  tableHandle: ResourceHandle,
-  keys: Tensor<Tin>,
-  _ values: Tensor<Tout>
-) {
-  let op = TFE_Op("LookupTableImportV2")
-  op.setAttr("Tin", Tin.tensorFlowDataType)
-  op.setAttr("Tout", Tout.tensorFlowDataType)
-  let _ = op.addInput(tableHandle)
-  let _ = op.addInput(keys)
-  let _ = op.addInput(values)
-  op.execute()
-}
-
-/// Updates the table to associates keys with values.
-///
-/// The tensor `keys` must be of the same type as the keys of the table.
-/// The tensor `values` must be of the type of the table values.
-///
-/// - Parameters:
-///   - table_handle: Handle to the table.
-///   - keys: Any shape.  Keys to look up.
-///   - values: Values to associate with keys.
-@inlinable
-public static func lookupTableInsertV2<
-    Tin: TensorFlowScalar,
-    Tout: TensorFlowScalar
->(
-  tableHandle: ResourceHandle,
-  keys: Tensor<Tin>,
-  _ values: Tensor<Tout>
-) {
-  let op = TFE_Op("LookupTableInsertV2")
-  op.setAttr("Tin", Tin.tensorFlowDataType)
-  op.setAttr("Tout", Tout.tensorFlowDataType)
-  let _ = op.addInput(tableHandle)
-  let _ = op.addInput(keys)
-  let _ = op.addInput(values)
-  op.execute()
-}
-
-/// Removes keys and its associated values from a table.
-///
-/// The tensor `keys` must of the same type as the keys of the table. Keys not
-/// already in the table are silently ignored.
-///
-/// - Parameters:
-///   - table_handle: Handle to the table.
-///   - keys: Any shape.  Keys of the elements to remove.
-@inlinable
-public static func lookupTableRemoveV2<Tin: TensorFlowScalar>(
-  tableHandle: ResourceHandle,
-  keys: Tensor<Tin>
-) {
-  let op = TFE_Op("LookupTableRemoveV2")
-  op.setAttr("Tin", Tin.tensorFlowDataType)
-  let _ = op.addInput(tableHandle)
-  let _ = op.addInput(keys)
-  op.execute()
-}
-
-/// Computes the number of elements in the given table.
-///
-/// - Parameter table_handle: Handle to the table.
-///
-/// - Output size: Scalar that contains number of elements in the table.
-@inlinable
-public static func lookupTableSizeV2(
-  tableHandle: ResourceHandle
-) -> Tensor<Int64> {
-  let op = TFE_Op("LookupTableSizeV2")
-  let _ = op.addInput(tableHandle)
-  return op.execute(Int(1))
-}
-
-/// Forwards the input to the output.
-///
-/// This operator represents the loop termination condition used by the
-/// "pivot" switches of a loop.
-///
-/// - Parameter input: A boolean scalar, representing the branch predicate of the Switch op.
-///
-/// - Output output: The same tensor as `input`.
-@inlinable
-public static func loopCond(
-  _ input: Tensor<Bool>
-) -> Tensor<Bool> {
-  let op = TFE_Op("LoopCond")
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Applies lower_bound(sorted_search_values, values) along each row.
-///
-/// Each set of rows with the same index in (sorted_inputs, values) is treated
-/// independently.  The resulting row is the equivalent of calling
-/// `np.searchsorted(sorted_inputs, values, side='left')`.
-///
-/// The result is not a global index to the entire 
-/// `Tensor`, but rather just the index in the last dimension.
-///
-/// A 2-D example:
-///   sorted_sequence = [[0, 3, 9, 9, 10],
-///                      [1, 2, 3, 4, 5]]
-///   values = [[2, 4, 9],
-///             [0, 2, 6]]
-///
-///   result = LowerBound(sorted_sequence, values)
-///
-///   result == [[1, 2, 2],
-///              [0, 1, 5]]
-///
-/// - Parameters:
-///   - sorted_inputs: 2-D Tensor where each row is ordered.
-///   - values: 2-D Tensor with the same numbers of rows as `sorted_search_values`. Contains
-///     the values that will be searched for in `sorted_search_values`.
-///
-/// - Output output: A `Tensor` with the same shape as `values`.  It contains the first scalar index
-///   into the last dimension where values can be inserted without changing the
-///   ordered property.
-@inlinable
-public static func lowerBound<
-    T: TensorFlowScalar,
-    OutType: BinaryInteger & TensorFlowScalar
->(
-  sortedInputs: Tensor<T>,
-  _ values: Tensor<T>
-) -> Tensor<OutType> {
-  let op = TFE_Op("LowerBound")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(sortedInputs)
-  let _ = op.addInput(values)
-  return op.execute(Int(1))
-}
-
-/// Computes the LU decomposition of one or more square matrices.
-///
-/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-/// form square matrices.
-///
-/// The input has to be invertible.
-///
-/// The output consists of two tensors LU and P containing the LU decomposition
-/// of all input submatrices `[..., :, :]`. LU encodes the lower triangular and
-/// upper triangular factors.
-///
-/// For each input submatrix of shape `[M, M]`, L is a lower triangular matrix of
-/// shape `[M, M]` with unit diagonal whose entries correspond to the strictly lower
-/// triangular part of LU. U is a upper triangular matrix of shape `[M, M]` whose
-/// entries correspond to the upper triangular part, including the diagonal, of LU.
-///
-/// P represents a permutation matrix encoded as a list of indices each between `0`
-/// and `M-1`, inclusive. If P_mat denotes the permutation matrix corresponding to
-/// P, then the L, U and P satisfies P_mat * input = L * U.
-///
-/// - Parameter input: A tensor of shape `[..., M, M]` whose inner-most 2 dimensions form matrices of
-///   size `[M, M]`.
-///
-/// - Outputs:
-///   - lu: A tensor of shape `[..., M, M]` whose strictly lower triangular part denotes the
-///     lower triangular factor `L` with unit diagonal, and whose upper triangular part
-///     denotes the upper triangular factor `U`.
-///   - p: Permutation of the rows encoded as a list of indices in `0..M-1`. Shape is
-///     `[..., M]`.
-///     @compatibility(scipy)
-///     Similar to `scipy.linalg.lu`, except the triangular factors `L` and `U` are
-///     packed into a single tensor, the permutation is applied to `input` instead of
-///     the right hand side and the permutation `P` is returned as a list of indices
-///     instead of a permutation matrix.
-///     @end_compatibility
-@inlinable
-public static func lu<
-    T: FloatingPoint & TensorFlowScalar,
-    OutputIdxType: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>
-) -> (lu: Tensor<T>, p: Tensor<OutputIdxType>) {
-  let op = TFE_Op("Lu")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("output_idx_type", OutputIdxType.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Makes a new iterator from the given `dataset` and stores it in `iterator`.
-///
-/// This operation may be executed multiple times. Each execution will reset the
-/// iterator in `iterator` to the first element of `dataset`.
-@inlinable
-public static func makeIterator(
-  dataset: VariantHandle,
-  iterator: ResourceHandle
-) {
-  let op = TFE_Op("MakeIterator")
-  let _ = op.addInput(dataset)
-  let _ = op.addInput(iterator)
-  op.execute()
-}
-
-/// Op removes all elements in the underlying container.
-@inlinable
-public static func mapClear(
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  dtypes: [TensorDataType],
-  container: String,
-  sharedName: String
-) {
-  let op = TFE_Op("MapClear")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", dtypes)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.execute()
-}
-
-/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
-@inlinable
-public static func mapDataset<
-    FIn: TensorGroup,
-    FOut: TensorGroup,
-    Targuments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  otherArguments: Targuments,
-  f: (FIn) -> FOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?],
-  useInterOpParallelism: Bool = true,
-  preserveCardinality: Bool = false
-) -> VariantHandle {
-  let op = TFE_Op("MapDataset")
-  op.setAttr("f", f)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("use_inter_op_parallelism", useInterOpParallelism)
-  op.setAttr("preserve_cardinality", preserveCardinality)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(otherArguments)
-  return op.execute(Int(1))
-}
-
-///   Maps a function on the list of tensors unpacked from arguments on dimension 0.
-///   The function given by `f` is assumed to be stateless, and is executed
-///   concurrently on all the slices; up to batch_size (i.e. the size of the 0th
-///   dimension of each argument) functions will be scheduled at once.
-///
-///   The `max_intra_op_parallelism` attr, which defaults to 1, can be used to
-///   limit the intra op parallelism. To limit inter-op parallelism, a user can
-///   set a private threadpool on the dataset using `tf.data.Options`'s
-///   `ThreadingOptions`.
-///
-///   Note that this op is not exposed to users directly, but is invoked in tf.data
-///   rewrites.
-///
-/// - Parameters:
-///   - arguments:     A list of tensors whose types are `Targuments`, corresponding to the inputs
-///         the function should be mapped over.
-///   - captured_inputs:     A list of tensors whose types are `Tcaptured`, corresponding to the captured
-///         inputs of the defun.
-///
-/// - Attrs:
-///   - Targuments: A list of types.
-///   - Tcaptured: A list of types.
-///   - output_types: A list of types.
-///   - output_shapes: A list of shapes.
-///
-/// - Output output:     A list of output tensors whose types are `output_types` and whose dimensions
-///       0 are the same as the dimensions 0 of the tensors in `arguments`, and whose
-///       remaining dimensions correspond to those in `output_shapes`.
-@inlinable
-public static func mapDefun<
-    Targuments: TensorArrayProtocol,
-    Tcaptured: TensorArrayProtocol,
-    OutputTypes: TensorGroup,
-    FIn: TensorGroup,
-    FOut: TensorGroup
->(
-  arguments: Targuments,
-  capturedInputs: Tcaptured,
-  outputShapes: [TensorShape?],
-  f: (FIn) -> FOut,
-  maxIntraOpParallelism: Int64 = 1
-) -> OutputTypes {
-  let op = TFE_Op("MapDefun")
-  op.setAttr("Targuments", arguments._typeList)
-  op.setAttr("Tcaptured", capturedInputs._typeList)
-  op.setAttr("output_types", OutputTypes._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("f", f)
-  op.setAttr("max_intra_op_parallelism", maxIntraOpParallelism)
-  let _ = op.addInputList(arguments)
-  let _ = op.addInputList(capturedInputs)
-  return op.execute(Int(OutputTypes._typeList.count))
-}
-
-/// Op returns the number of incomplete elements in the underlying container.
-@inlinable
-public static func mapIncompleteSize(
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  dtypes: [TensorDataType],
-  container: String,
-  sharedName: String
-) -> Tensor<Int32> {
-  let op = TFE_Op("MapIncompleteSize")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", dtypes)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Op peeks at the values at the specified key.  If the
-///
-/// underlying container does not contain this key
-/// this op will block until it does.
-@inlinable
-public static func mapPeek<Dtypes: TensorGroup>(
-  key: Tensor<Int64>,
-  indices: Tensor<Int32>,
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  container: String,
-  sharedName: String
-) -> Dtypes {
-  let op = TFE_Op("MapPeek")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", Dtypes._typeList)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(key)
-  let _ = op.addInput(indices)
-  return op.execute(Int(Dtypes._typeList.count))
-}
-
-/// Op returns the number of elements in the underlying container.
-@inlinable
-public static func mapSize(
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  dtypes: [TensorDataType],
-  container: String,
-  sharedName: String
-) -> Tensor<Int32> {
-  let op = TFE_Op("MapSize")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", dtypes)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Stage (key, values) in the underlying container which behaves like a hashtable.
-///
-/// - Parameters:
-///   - key: int64
-///   - values: a list of tensors
-///     dtypes A list of data types that inserted values should adhere to.
-///
-/// - Attrs:
-///   - capacity: Maximum number of elements in the Staging Area. If > 0, inserts
-///     on the container will block when the capacity is reached.
-///   - container: If non-empty, this queue is placed in the given container. Otherwise,
-///     a default container is used.
-///   - shared_name: It is necessary to match this name to the matching Unstage Op.
-@inlinable
-public static func mapStage<FakeDtypes: TensorArrayProtocol>(
-  key: Tensor<Int64>,
-  indices: Tensor<Int32>,
-  _ values: FakeDtypes,
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  dtypes: [TensorDataType],
-  container: String,
-  sharedName: String
-) {
-  let op = TFE_Op("MapStage")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", dtypes)
-  op.setAttr("fake_dtypes", values._typeList)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(key)
-  let _ = op.addInput(indices)
-  let _ = op.addInputList(values)
-  op.execute()
-}
-
-/// Op removes and returns the values associated with the key
-///
-/// from the underlying container.   If the underlying container
-/// does not contain this key, the op will block until it does.
-@inlinable
-public static func mapUnstage<Dtypes: TensorGroup>(
-  key: Tensor<Int64>,
-  indices: Tensor<Int32>,
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  container: String,
-  sharedName: String
-) -> Dtypes {
-  let op = TFE_Op("MapUnstage")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", Dtypes._typeList)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(key)
-  let _ = op.addInput(indices)
-  return op.execute(Int(Dtypes._typeList.count))
-}
-
-/// Op removes and returns a random (key, value)
-///
-/// from the underlying container.   If the underlying container
-/// does not contain elements, the op will block until it does.
-@inlinable
-public static func mapUnstageNoKey<Dtypes: TensorGroup>(
-  indices: Tensor<Int32>,
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  container: String,
-  sharedName: String
-) -> (key: Tensor<Int64>, values: Dtypes) {
-  let op = TFE_Op("MapUnstageNoKey")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", Dtypes._typeList)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(indices)
-  return op.execute(Int(1), Int(Dtypes._typeList.count))
-}
-
-/// Multiply the matrix "a" by the matrix "b".
-///
-/// The inputs must be two-dimensional matrices and the inner dimension of
-/// "a" (after being transposed if transpose_a is true) must match the
-/// outer dimension of "b" (after being transposed if transposed_b is
-/// true).
-///
-/// *Note*: The default kernel implementation for MatMul on GPUs uses
-/// cublas.
-///
-/// - Attrs:
-///   - transpose_a: If true, "a" is transposed before multiplication.
-///   - transpose_b: If true, "b" is transposed before multiplication.
-@inlinable
-public static func matMul<T: Numeric & TensorFlowScalar>(
-  _ a: Tensor<T>,
-  _ b: Tensor<T>,
-  transposeA: Bool = false,
-  transposeB: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("MatMul")
-  op.setAttr("transpose_a", transposeA)
-  op.setAttr("transpose_b", transposeB)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  return op.execute(Int(1))
-}
-
-/// Returns the set of files matching one or more glob patterns.
-///
-/// Note that this routine only supports wildcard characters in the
-/// basename portion of the pattern, not in the directory portion.
-/// Note also that the order of filenames returned can be non-deterministic.
-///
-/// - Parameter pattern: Shell wildcard pattern(s). Scalar or vector of type string.
-///
-/// - Output filenames: A vector of matching filenames.
-@inlinable
-public static func matchingFiles(
-  pattern: StringTensor
-) -> StringTensor {
-  let op = TFE_Op("MatchingFiles")
-  let _ = op.addInput(pattern)
-  return op.execute(Int(1))
-}
-
-/// Copy a tensor setting everything outside a central band in each innermost matrix
-///
-/// to zero.
-///
-/// The `band` part is computed as follows:
-/// Assume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a
-/// tensor with the same shape where
-///
-/// `band[i, j, k, ..., m, n] = in_band(m, n) * input[i, j, k, ..., m, n]`.
-///
-/// The indicator function
-///
-/// `in_band(m, n) = (num_lower < 0 || (m-n) <= num_lower)) &&
-///                  (num_upper < 0 || (n-m) <= num_upper)`.
-///
-/// For example:
-///
-/// ```
-/// # if 'input' is [[ 0,  1,  2, 3]
-///                  [-1,  0,  1, 2]
-///                  [-2, -1,  0, 1]
-///                  [-3, -2, -1, 0]],
-///
-/// tf.matrix_band_part(input, 1, -1) ==> [[ 0,  1,  2, 3]
-///                                        [-1,  0,  1, 2]
-///                                        [ 0, -1,  0, 1]
-///                                        [ 0,  0, -1, 0]],
-///
-/// tf.matrix_band_part(input, 2, 1) ==> [[ 0,  1,  0, 0]
-///                                       [-1,  0,  1, 0]
-///                                       [-2, -1,  0, 1]
-///                                       [ 0, -2, -1, 0]]
-/// ```
-///
-/// Useful special cases:
-///
-/// ```
-///  tf.matrix_band_part(input, 0, -1) ==> Upper triangular part.
-///  tf.matrix_band_part(input, -1, 0) ==> Lower triangular part.
-///  tf.matrix_band_part(input, 0, 0) ==> Diagonal.
-/// ```
-///
-/// - Parameters:
-///   - input: Rank `k` tensor.
-///   - num_lower: 0-D tensor. Number of subdiagonals to keep. If negative, keep entire
-///     lower triangle.
-///   - num_upper: 0-D tensor. Number of superdiagonals to keep. If negative, keep
-///     entire upper triangle.
-///
-/// - Output band: Rank `k` tensor of the same shape as input. The extracted banded tensor.
-@inlinable
-public static func matrixBandPart<
-    T: TensorFlowScalar,
-    Tindex: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  numLower: Tensor<Tindex>,
-  numUpper: Tensor<Tindex>
-) -> Tensor<T> {
-  let op = TFE_Op("MatrixBandPart")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindex", Tindex.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(numLower)
-  let _ = op.addInput(numUpper)
-  return op.execute(Int(1))
-}
-
-/// Computes the determinant of one or more square matrices.
-///
-/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-/// form square matrices. The output is a tensor containing the determinants
-/// for all input submatrices `[..., :, :]`.
-///
-/// - Parameter input: Shape is `[..., M, M]`.
-///
-/// - Output output: Shape is `[...]`.
-@inlinable
-public static func matrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("MatrixDeterminant")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Returns a batched diagonal tensor with a given batched diagonal values.
-///
-/// Given a `diagonal`, this operation returns a tensor with the `diagonal` and
-/// everything else padded with zeros. The diagonal is computed as follows:
-///
-/// Assume `diagonal` has `k` dimensions `[I, J, K, ..., N]`, then the output is a
-/// tensor of rank `k+1` with dimensions [I, J, K, ..., N, N]` where:
-///
-/// `output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n]`.
-///
-/// For example:
-///
-/// ```
-/// # 'diagonal' is [[1, 2, 3, 4], [5, 6, 7, 8]]
-///
-/// and diagonal.shape = (2, 4)
-///
-/// tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0]
-///                                      [0, 2, 0, 0]
-///                                      [0, 0, 3, 0]
-///                                      [0, 0, 0, 4]],
-///                                     [[5, 0, 0, 0]
-///                                      [0, 6, 0, 0]
-///                                      [0, 0, 7, 0]
-///                                      [0, 0, 0, 8]]]
-///
-/// which has shape (2, 4, 4)
-/// ```
-///
-/// - Parameter diagonal: Rank `k`, where `k >= 1`.
-///
-/// - Output output: Rank `k+1`, with `output.shape = diagonal.shape + [diagonal.shape[-1]]`.
-@inlinable
-public static func matrixDiag<T: TensorFlowScalar>(
-  diagonal: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("MatrixDiag")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(diagonal)
-  return op.execute(Int(1))
-}
-
-/// Returns the batched diagonal part of a batched tensor.
-///
-/// This operation returns a tensor with the `diagonal` part
-/// of the batched `input`. The `diagonal` part is computed as follows:
-///
-/// Assume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a
-/// tensor of rank `k - 1` with dimensions `[I, J, K, ..., min(M, N)]` where:
-///
-/// `diagonal[i, j, k, ..., n] = input[i, j, k, ..., n, n]`.
-///
-/// The input must be at least a matrix.
-///
-/// For example:
-///
-/// ```
-/// # 'input' is [[[1, 0, 0, 0]
-///                [0, 2, 0, 0]
-///                [0, 0, 3, 0]
-///                [0, 0, 0, 4]],
-///               [[5, 0, 0, 0]
-///                [0, 6, 0, 0]
-///                [0, 0, 7, 0]
-///                [0, 0, 0, 8]]]
-///
-/// and input.shape = (2, 4, 4)
-///
-/// tf.matrix_diag_part(input) ==> [[1, 2, 3, 4], [5, 6, 7, 8]]
-///
-/// which has shape (2, 4)
-/// ```
-///
-/// - Parameter input: Rank `k` tensor where `k >= 2`.
-///
-/// - Output diagonal: The extracted diagonal(s) having shape
-///   `diagonal.shape = input.shape[:-2] + [min(input.shape[-2:])]`.
-@inlinable
-public static func matrixDiagPart<T: TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("MatrixDiagPart")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Deprecated, use python implementation tf.linalg.matrix_exponential.
-@inlinable
-public static func matrixExponential<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("MatrixExponential")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Computes the inverse of one or more square invertible matrices or their
-///
-/// adjoints (conjugate transposes).
-///
-/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-/// form square matrices. The output is a tensor of the same shape as the input
-/// containing the inverse for all input submatrices `[..., :, :]`.
-///
-/// The op uses LU decomposition with partial pivoting to compute the inverses.
-///
-/// If a matrix is not invertible there is no guarantee what the op does. It
-/// may detect the condition and raise an exception or it may simply return a
-/// garbage result.
-///
-/// - Parameter input: Shape is `[..., M, M]`.
-///
-/// - Output output: Shape is `[..., M, M]`.
-///
-///   @compatibility(numpy)
-///   Equivalent to np.linalg.inv
-///   @end_compatibility
-@inlinable
-public static func matrixInverse<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  adjoint: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("MatrixInverse")
-  op.setAttr("adjoint", adjoint)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Computes the matrix logarithm of one or more square matrices:
-///
-///
-/// \\(log(exp(A)) = A\\)
-///
-/// This op is only defined for complex matrices. If A is positive-definite and
-/// real, then casting to a complex matrix, taking the logarithm and casting back
-/// to a real matrix will give the correct result.
-///
-/// This function computes the matrix logarithm using the Schur-Parlett algorithm.
-/// Details of the algorithm can be found in Section 11.6.2 of:
-/// Nicholas J. Higham, Functions of Matrices: Theory and Computation, SIAM 2008.
-/// ISBN 978-0-898716-46-7.
-///
-/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-/// form square matrices. The output is a tensor of the same shape as the input
-/// containing the exponential for all input submatrices `[..., :, :]`.
-///
-/// - Parameter input: Shape is `[..., M, M]`.
-///
-/// - Output output: Shape is `[..., M, M]`.
-///
-///   @compatibility(scipy)
-///   Equivalent to scipy.linalg.logm
-///   @end_compatibility
-@inlinable
-public static func matrixLogarithm<T: TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("MatrixLogarithm")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(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`.
-///
-/// - Parameters:
-///   - input: Rank `k+1`, where `k >= 1`.
-///   - diagonal: Rank `k`, where `k >= 1`.
-///
-/// - Output output: Rank `k+1`, with `output.shape = input.shape`.
-@inlinable
-public static func matrixSetDiag<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  diagonal: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("MatrixSetDiag")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(diagonal)
-  return op.execute(Int(1))
-}
-
-/// Solves systems of linear equations.
-///
-/// `Matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-/// form square matrices. `Rhs` is a tensor of shape `[..., M, K]`. The `output` is
-/// a tensor shape `[..., M, K]`.  If `adjoint` is `False` then each output matrix
-/// satisfies `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
-/// If `adjoint` is `True` then each output matrix satisfies
-/// `adjoint(matrix[..., :, :]) * output[..., :, :] = rhs[..., :, :]`.
-///
-/// - Parameters:
-///   - matrix: Shape is `[..., M, M]`.
-///   - rhs: Shape is `[..., M, K]`.
-///
-/// - Attr adjoint: Boolean indicating whether to solve with `matrix` or its (block-wise)
-///   adjoint.
-///
-/// - Output output: Shape is `[..., M, K]`.
-@inlinable
-public static func matrixSolve<T: FloatingPoint & TensorFlowScalar>(
-  matrix: Tensor<T>,
-  rhs: Tensor<T>,
-  adjoint: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("MatrixSolve")
-  op.setAttr("adjoint", adjoint)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(matrix)
-  let _ = op.addInput(rhs)
-  return op.execute(Int(1))
-}
-
-/// Solves one or more linear least-squares problems.
-///
-/// `matrix` is a tensor of shape `[..., M, N]` whose inner-most 2 dimensions
-/// form real or complex matrices of size `[M, N]`. `Rhs` is a tensor of the same
-/// type as `matrix` and shape `[..., M, K]`.
-/// The output is a tensor shape `[..., N, K]` where each output matrix solves
-/// each of the equations
-/// `matrix[..., :, :]` * `output[..., :, :]` = `rhs[..., :, :]`
-/// in the least squares sense.
-///
-/// We use the following notation for (complex) matrix and right-hand sides
-/// in the batch:
-///
-/// `matrix`=\\(A \in \mathbb{C}^{m \times n}\\),
-/// `rhs`=\\(B  \in \mathbb{C}^{m \times k}\\),
-/// `output`=\\(X  \in \mathbb{C}^{n \times k}\\),
-/// `l2_regularizer`=\\(\lambda \in \mathbb{R}\\).
-///
-/// If `fast` is `True`, then the solution is computed by solving the normal
-/// equations using Cholesky decomposition. Specifically, if \\(m \ge n\\) then
-/// \\(X = (A^H A + \lambda I)^{-1} A^H B\\), which solves the least-squares
-/// problem \\(X = \mathrm{argmin}_{Z \in \Re^{n \times k} } ||A Z - B||_F^2 + \lambda ||Z||_F^2\\). 
-/// If \\(m \lt n\\) then `output` is computed as
-/// \\(X = A^H (A A^H + \lambda I)^{-1} B\\), which (for \\(\lambda = 0\\)) is the
-/// minimum-norm solution to the under-determined linear system, i.e.
-/// \\(X = \mathrm{argmin}_{Z \in \mathbb{C}^{n \times k} } ||Z||_F^2 \\),
-/// subject to \\(A Z = B\\). Notice that the fast path is only numerically stable
-/// when \\(A\\) is numerically full rank and has a condition number
-/// \\(\mathrm{cond}(A) \lt \frac{1}{\sqrt{\epsilon_{mach} } }\\) or \\(\lambda\\) is
-/// sufficiently large.
-///
-/// If `fast` is `False` an algorithm based on the numerically robust complete
-/// orthogonal decomposition is used. This computes the minimum-norm
-/// least-squares solution, even when \\(A\\) is rank deficient. This path is
-/// typically 6-7 times slower than the fast path. If `fast` is `False` then
-/// `l2_regularizer` is ignored.
-///
-/// - Parameters:
-///   - matrix: Shape is `[..., M, N]`.
-///   - rhs: Shape is `[..., M, K]`.
-///   - l2_regularizer: Scalar tensor.
-///
-///     @compatibility(numpy)
-///     Equivalent to np.linalg.lstsq
-///     @end_compatibility
-///
-/// - Output output: Shape is `[..., N, K]`.
-@inlinable
-public static func matrixSolveLs<T: FloatingPoint & TensorFlowScalar>(
-  matrix: Tensor<T>,
-  rhs: Tensor<T>,
-  l2Regularizer: Tensor<Double>,
-  fast: Bool = true
-) -> Tensor<T> {
-  let op = TFE_Op("MatrixSolveLs")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("fast", fast)
-  let _ = op.addInput(matrix)
-  let _ = op.addInput(rhs)
-  let _ = op.addInput(l2Regularizer)
-  return op.execute(Int(1))
-}
-
-/// Computes the matrix square root of one or more square matrices:
-///
-/// matmul(sqrtm(A), sqrtm(A)) = A
-///
-/// The input matrix should be invertible. If the input matrix is real, it should
-/// have no eigenvalues which are real and negative (pairs of complex conjugate
-/// eigenvalues are allowed).
-///
-/// The matrix square root is computed by first reducing the matrix to 
-/// quasi-triangular form with the real Schur decomposition. The square root 
-/// of the quasi-triangular matrix is then computed directly. Details of 
-/// the algorithm can be found in: Nicholas J. Higham, "Computing real 
-/// square roots of a real matrix", Linear Algebra Appl., 1987.
-///
-/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-/// form square matrices. The output is a tensor of the same shape as the input
-/// containing the matrix square root for all input submatrices `[..., :, :]`.
-///
-/// - Parameter input: Shape is `[..., M, M]`.
-///
-/// - Output output: Shape is `[..., M, M]`.
-///
-///   @compatibility(scipy)
-///   Equivalent to scipy.linalg.sqrtm
-///   @end_compatibility
-@inlinable
-public static func matrixSquareRoot<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("MatrixSquareRoot")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Solves systems of linear equations with upper or lower triangular matrices by
-///
-/// backsubstitution.
-///
-/// `matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions form
-/// square matrices. If `lower` is `True` then the strictly upper triangular part
-/// of each inner-most matrix is assumed to be zero and not accessed.
-/// If `lower` is False then the strictly lower triangular part of each inner-most
-/// matrix is assumed to be zero and not accessed.
-/// `rhs` is a tensor of shape `[..., M, K]`.
-///
-/// The output is a tensor of shape `[..., M, K]`. If `adjoint` is
-/// `True` then the innermost matrices in `output` satisfy matrix equations
-/// `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
-/// If `adjoint` is `False` then the strictly then the  innermost matrices in
-/// `output` satisfy matrix equations
-/// `adjoint(matrix[..., i, k]) * output[..., k, j] = rhs[..., i, j]`.
-///
-/// - Parameters:
-///   - matrix: Shape is `[..., M, M]`.
-///   - rhs: Shape is `[..., M, K]`.
-///
-/// - Attrs:
-///   - lower: Boolean indicating whether the innermost matrices in `matrix` are
-///     lower or upper triangular.
-///   - adjoint: Boolean indicating whether to solve with `matrix` or its (block-wise)
-///              adjoint.
-///
-///     @compatibility(numpy)
-///     Equivalent to scipy.linalg.solve_triangular
-///     @end_compatibility
-///
-/// - Output output: Shape is `[..., M, K]`.
-@inlinable
-public static func matrixTriangularSolve<T: FloatingPoint & TensorFlowScalar>(
-  matrix: Tensor<T>,
-  rhs: Tensor<T>,
-  lower: Bool = true,
-  adjoint: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("MatrixTriangularSolve")
-  op.setAttr("lower", lower)
-  op.setAttr("adjoint", adjoint)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(matrix)
-  let _ = op.addInput(rhs)
-  return op.execute(Int(1))
-}
-
-/// Computes the maximum of elements across dimensions of a tensor.
-///
-/// Reduces `input` along the dimensions given in `axis`. Unless
-/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-/// `axis`. If `keep_dims` is true, the reduced dimensions are
-/// retained with length 1.
-///
-/// - Parameters:
-///   - input: The tensor to reduce.
-///   - reduction_indices: The dimensions to reduce. Must be in the range
-///     `[-rank(input), rank(input))`.
-///
-/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-///
-/// - Output output: The reduced tensor.
-@inlinable
-public static func max<
-    T: Numeric & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  reductionIndices: Tensor<Tidx>,
-  keepDims: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("Max")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(reductionIndices)
-  return op.execute(Int(1))
-}
-
-/// Performs max pooling on the input.
-///
-/// - Parameter input: 4-D input to pool over.
-///
-/// - Attrs:
-///   - ksize: The size of the window for each dimension of the input tensor.
-///   - strides: The stride of the sliding window for each dimension of the
-///     input tensor.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, in_channels, in_height, in_width].
-///
-/// - Output output: The max pooled output tensor.
-@inlinable
-public static func maxPool<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat4 = .nhwc
-) -> Tensor<T> {
-  let op = TFE_Op("MaxPool")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Performs 3D max pooling on the input.
-///
-/// - Parameter input: Shape `[batch, depth, rows, cols, channels]` tensor to pool over.
-///
-/// - Attrs:
-///   - ksize: 1-D tensor of length 5. The size of the window for each dimension of
-///     the input tensor. Must have `ksize[0] = ksize[4] = 1`.
-///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
-///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: The data format of the input and output data. With the
-///     default format "NDHWC", the data is stored in the order of:
-///         [batch, in_depth, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCDHW", the data storage order is:
-///         [batch, in_channels, in_depth, in_height, in_width].
-///
-/// - Output output: The max pooled output tensor.
-@inlinable
-public static func maxPool3D<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat1 = .ndhwc
-) -> Tensor<T> {
-  let op = TFE_Op("MaxPool3D")
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Computes gradients of max pooling function.
-///
-/// - Parameters:
-///   - orig_input: The original input tensor.
-///   - orig_output: The original output tensor.
-///   - grad: Output backprop of shape `[batch, depth, rows, cols, channels]`.
-///
-/// - Attrs:
-///   - ksize: 1-D tensor of length 5. The size of the window for each dimension of
-///     the input tensor. Must have `ksize[0] = ksize[4] = 1`.
-///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
-///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: The data format of the input and output data. With the
-///     default format "NDHWC", the data is stored in the order of:
-///         [batch, in_depth, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCDHW", the data storage order is:
-///         [batch, in_channels, in_depth, in_height, in_width].
-@inlinable
-public static func maxPool3DGrad<
-    T: FloatingPoint & TensorFlowScalar,
-    Tinput: FloatingPoint & TensorFlowScalar
->(
-  origInput: Tensor<Tinput>,
-  origOutput: Tensor<Tinput>,
-  grad: Tensor<T>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat1 = .ndhwc
-) -> Tensor<T> {
-  let op = TFE_Op("MaxPool3DGrad")
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("TInput", Tinput.tensorFlowDataType)
-  let _ = op.addInput(origInput)
-  let _ = op.addInput(origOutput)
-  let _ = op.addInput(grad)
-  return op.execute(Int(1))
-}
-
-/// Computes second-order gradients of the maxpooling function.
-///
-/// - Parameters:
-///   - orig_input: The original input tensor.
-///   - orig_output: The original output tensor.
-///   - grad: Output backprop of shape `[batch, depth, rows, cols, channels]`.
-///
-/// - Attrs:
-///   - ksize: 1-D tensor of length 5. The size of the window for each dimension of
-///     the input tensor. Must have `ksize[0] = ksize[4] = 1`.
-///   - strides: 1-D tensor of length 5. The stride of the sliding window for each
-///     dimension of `input`. Must have `strides[0] = strides[4] = 1`.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: The data format of the input and output data. With the
-///     default format "NDHWC", the data is stored in the order of:
-///         [batch, in_depth, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCDHW", the data storage order is:
-///         [batch, in_channels, in_depth, in_height, in_width].
-///
-/// - Output output: Gradients of gradients w.r.t. the input to `max_pool`.
-@inlinable
-public static func maxPool3DGradGrad<T: Numeric & TensorFlowScalar>(
-  origInput: Tensor<T>,
-  origOutput: Tensor<T>,
-  grad: Tensor<T>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat1 = .ndhwc
-) -> Tensor<T> {
-  let op = TFE_Op("MaxPool3DGradGrad")
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(origInput)
-  let _ = op.addInput(origOutput)
-  let _ = op.addInput(grad)
-  return op.execute(Int(1))
-}
-
-/// Computes gradients of the maxpooling function.
-///
-/// - Parameters:
-///   - orig_input: The original input tensor.
-///   - orig_output: The original output tensor.
-///   - grad: 4-D.  Gradients w.r.t. the output of `max_pool`.
-///
-/// - Attrs:
-///   - ksize: The size of the window for each dimension of the input tensor.
-///   - strides: The stride of the sliding window for each dimension of the
-///     input tensor.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, in_channels, in_height, in_width].
-///
-/// - Output output: Gradients w.r.t. the input to `max_pool`.
-@inlinable
-public static func maxPoolGrad<T: Numeric & TensorFlowScalar>(
-  origInput: Tensor<T>,
-  origOutput: Tensor<T>,
-  grad: Tensor<T>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat = .nhwc
-) -> Tensor<T> {
-  let op = TFE_Op("MaxPoolGrad")
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(origInput)
-  let _ = op.addInput(origOutput)
-  let _ = op.addInput(grad)
-  return op.execute(Int(1))
-}
-
-/// Computes second-order gradients of the maxpooling function.
-///
-/// - Parameters:
-///   - orig_input: The original input tensor.
-///   - orig_output: The original output tensor.
-///   - grad: 4-D.  Gradients of gradients w.r.t. the input of `max_pool`.
-///
-/// - Attrs:
-///   - ksize: The size of the window for each dimension of the input tensor.
-///   - strides: The stride of the sliding window for each dimension of the
-///     input tensor.
-///   - padding: The type of padding algorithm to use.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, in_channels, in_height, in_width].
-///
-/// - Output output: Gradients of gradients w.r.t. the input to `max_pool`.
-@inlinable
-public static func maxPoolGradGrad<T: Numeric & TensorFlowScalar>(
-  origInput: Tensor<T>,
-  origOutput: Tensor<T>,
-  grad: Tensor<T>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  dataFormat: DataFormat = .nhwc
-) -> Tensor<T> {
-  let op = TFE_Op("MaxPoolGradGrad")
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(origInput)
-  let _ = op.addInput(origOutput)
-  let _ = op.addInput(grad)
-  return op.execute(Int(1))
-}
-
-/// Computes second-order gradients of the maxpooling function.
-///
-/// - Parameters:
-///   - orig_input: The original input tensor.
-///   - orig_output: The original output tensor.
-///   - grad: 4-D.  Gradients of gradients w.r.t. the input of `max_pool`.
-///   - ksize: The size of the window for each dimension of the input tensor.
-///   - strides: The stride of the sliding window for each dimension of the
-///     input tensor.
-///
-/// - Attrs:
-///   - padding: The type of padding algorithm to use.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, in_channels, in_height, in_width].
-///
-/// - Output output: Gradients of gradients w.r.t. the input to `max_pool`.
-@inlinable
-public static func maxPoolGradGradV2<T: Numeric & TensorFlowScalar>(
-  origInput: Tensor<T>,
-  origOutput: Tensor<T>,
-  grad: Tensor<T>,
-  ksize: Tensor<Int32>,
-  strides: Tensor<Int32>,
-  padding: Padding,
-  dataFormat: DataFormat = .nhwc
-) -> Tensor<T> {
-  let op = TFE_Op("MaxPoolGradGradV2")
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(origInput)
-  let _ = op.addInput(origOutput)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(ksize)
-  let _ = op.addInput(strides)
-  return op.execute(Int(1))
-}
-
-/// Computes second-order gradients of the maxpooling function.
-///
-/// - Parameters:
-///   - input: The original input.
-///   - grad: 4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t. the
-///     input of `max_pool`.
-///   - argmax: The indices of the maximum values chosen for each output of `max_pool`.
-///
-/// - Attrs:
-///   - ksize: The size of the window for each dimension of the input tensor.
-///   - strides: The stride of the sliding window for each dimension of the
-///     input tensor.
-///   - padding: The type of padding algorithm to use.
-///   - include_batch_in_index: Whether to include batch dimension in flattened index of `argmax`.
-///
-/// - Output output: Gradients of gradients w.r.t. the input of `max_pool`.
-@inlinable
-public static func maxPoolGradGradWithArgmax<
-    Targmax: BinaryInteger & TensorFlowScalar,
-    T: Numeric & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  grad: Tensor<T>,
-  argmax: Tensor<Targmax>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  includeBatchInIndex: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("MaxPoolGradGradWithArgmax")
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("include_batch_in_index", includeBatchInIndex)
-  op.setAttr("Targmax", Targmax.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(argmax)
-  return op.execute(Int(1))
-}
-
-/// Computes gradients of the maxpooling function.
-///
-/// - Parameters:
-///   - orig_input: The original input tensor.
-///   - orig_output: The original output tensor.
-///   - grad: 4-D.  Gradients w.r.t. the output of `max_pool`.
-///   - ksize: The size of the window for each dimension of the input tensor.
-///   - strides: The stride of the sliding window for each dimension of the
-///     input tensor.
-///
-/// - Attrs:
-///   - padding: The type of padding algorithm to use.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, in_channels, in_height, in_width].
-///
-/// - Output output: Gradients w.r.t. the input to `max_pool`.
-@inlinable
-public static func maxPoolGradV2<T: Numeric & TensorFlowScalar>(
-  origInput: Tensor<T>,
-  origOutput: Tensor<T>,
-  grad: Tensor<T>,
-  ksize: Tensor<Int32>,
-  strides: Tensor<Int32>,
-  padding: Padding,
-  dataFormat: DataFormat = .nhwc
-) -> Tensor<T> {
-  let op = TFE_Op("MaxPoolGradV2")
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(origInput)
-  let _ = op.addInput(origOutput)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(ksize)
-  let _ = op.addInput(strides)
-  return op.execute(Int(1))
-}
-
-/// Computes gradients of the maxpooling function.
-///
-/// - Parameters:
-///   - input: The original input.
-///   - grad: 4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t. the
-///     output of `max_pool`.
-///   - argmax: The indices of the maximum values chosen for each output of `max_pool`.
-///
-/// - Attrs:
-///   - ksize: The size of the window for each dimension of the input tensor.
-///   - strides: The stride of the sliding window for each dimension of the
-///     input tensor.
-///   - padding: The type of padding algorithm to use.
-///   - include_batch_in_index: Whether to include batch dimension in flattened index of `argmax`.
-///
-/// - Output output: Gradients w.r.t. the input of `max_pool`.
-@inlinable
-public static func maxPoolGradWithArgmax<
-    Targmax: BinaryInteger & TensorFlowScalar,
-    T: Numeric & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  grad: Tensor<T>,
-  argmax: Tensor<Targmax>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  includeBatchInIndex: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("MaxPoolGradWithArgmax")
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("include_batch_in_index", includeBatchInIndex)
-  op.setAttr("Targmax", Targmax.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(argmax)
-  return op.execute(Int(1))
-}
-
-/// Performs max pooling on the input.
-///
-/// - Parameters:
-///   - input: 4-D input to pool over.
-///   - ksize: The size of the window for each dimension of the input tensor.
-///   - strides: The stride of the sliding window for each dimension of the
-///     input tensor.
-///
-/// - Attrs:
-///   - padding: The type of padding algorithm to use.
-///   - data_format: Specify the data format of the input and output data. With the
-///     default format "NHWC", the data is stored in the order of:
-///         [batch, in_height, in_width, in_channels].
-///     Alternatively, the format could be "NCHW", the data storage order of:
-///         [batch, in_channels, in_height, in_width].
-///
-/// - Output output: The max pooled output tensor.
-@inlinable
-public static func maxPoolV2<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  ksize: Tensor<Int32>,
-  strides: Tensor<Int32>,
-  padding: Padding,
-  dataFormat: DataFormat4 = .nhwc
-) -> Tensor<T> {
-  let op = TFE_Op("MaxPoolV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("data_format", dataFormat.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(ksize)
-  let _ = op.addInput(strides)
-  return op.execute(Int(1))
-}
-
-/// Performs max pooling on the input and outputs both max values and indices.
-///
-/// The indices in `argmax` are flattened, so that a maximum value at position
-/// `[b, y, x, c]` becomes flattened index:
-/// `(y * width + x) * channels + c` if `include_batch_in_index` is False;
-/// `((b * height + y) * width + x) * channels + c` if `include_batch_in_index` is True.
-///
-/// The indices returned are always in `[0, height) x [0, width)` before flattening,
-/// even if padding is involved and the mathematically correct answer is outside
-/// (either negative or too large).  This is a bug, but fixing it is difficult to do
-/// in a safe backwards compatible way, especially due to flattening.
-///
-/// - Parameter input: 4-D with shape `[batch, height, width, channels]`.  Input to pool over.
-///
-/// - Attrs:
-///   - ksize: The size of the window for each dimension of the input tensor.
-///   - strides: The stride of the sliding window for each dimension of the
-///     input tensor.
-///   - padding: The type of padding algorithm to use.
-///   - include_batch_in_index: Whether to include batch dimension in flattened index of `argmax`.
-///
-/// - Outputs:
-///   - output: The max pooled output tensor.
-///   - argmax: 4-D.  The flattened indices of the max values chosen for each output.
-@inlinable
-public static func maxPoolWithArgmax<
-    Targmax: BinaryInteger & TensorFlowScalar,
-    T: Numeric & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding,
-  includeBatchInIndex: Bool = false
-) -> (output: Tensor<T>, argmax: Tensor<Targmax>) {
-  let op = TFE_Op("MaxPoolWithArgmax")
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("Targmax", Targmax.tensorFlowDataType)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("include_batch_in_index", includeBatchInIndex)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Returns the max of x and y (i.e. x > y ? x : y) element-wise.
-///
-/// *NOTE*: `Maximum` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func maximum<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Maximum")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Computes the mean of elements across dimensions of a tensor.
-///
-/// Reduces `input` along the dimensions given in `axis`. Unless
-/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-/// `axis`. If `keep_dims` is true, the reduced dimensions are
-/// retained with length 1.
-///
-/// - Parameters:
-///   - input: The tensor to reduce.
-///   - reduction_indices: The dimensions to reduce. Must be in the range
-///     `[-rank(input), rank(input))`.
-///
-/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-///
-/// - Output output: The reduced tensor.
-@inlinable
-public static func mean<
-    T: Numeric & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  reductionIndices: Tensor<Tidx>,
-  keepDims: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("Mean")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(reductionIndices)
-  return op.execute(Int(1))
-}
-
-/// Forwards the value of an available tensor from `inputs` to `output`.
-///
-/// `Merge` waits for at least one of the tensors in `inputs` to become available.
-/// It is usually combined with `Switch` to implement branching.
-///
-/// `Merge` forwards the first tensor to become available to `output`, and sets
-/// `value_index` to its index in `inputs`.
-///
-/// - Parameter inputs: The input tensors, exactly one of which will become available.
-///
-/// - Outputs:
-///   - output: Will be set to the available input tensor.
-///   - value_index: The index of the chosen input tensor in `inputs`.
-@inlinable
-public static func merge<T: TensorFlowScalar>(
-  inputs: [Tensor<T>]
-) -> (output: Tensor<T>, valueIndex: Tensor<Int32>) {
-  let op = TFE_Op("Merge")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("N", inputs.count)
-  let _ = op.addInputList(inputs)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Merges summaries.
-///
-/// This op creates a
-/// [`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto)
-/// protocol buffer that contains the union of all the values in the input
-/// summaries.
-///
-/// When the Op is run, it reports an `InvalidArgument` error if multiple values
-/// in the summaries to merge use the same tag.
-///
-/// - Parameter inputs: Can be of any shape.  Each must contain serialized `Summary` protocol
-///   buffers.
-///
-/// - Output summary: Scalar. Serialized `Summary` protocol buffer.
-@inlinable
-public static func mergeSummary(
-  inputs: [StringTensor]
-) -> StringTensor {
-  let op = TFE_Op("MergeSummary")
-  op.setAttr("N", inputs.count)
-  let _ = op.addInputList(inputs)
-  return op.execute(Int(1))
-}
-
-/// V2 format specific: merges the metadata files of sharded checkpoints.  The
-///
-/// result is one logical checkpoint, with one physical metadata file and renamed
-/// data files.
-///
-/// Intended for "grouping" multiple checkpoints in a sharded checkpoint setup.
-///
-/// If delete_old_dirs is true, attempts to delete recursively the dirname of each
-/// path in the input checkpoint_prefixes.  This is useful when those paths are non
-/// user-facing temporary locations.
-///
-/// - Parameters:
-///   - checkpoint_prefixes: prefixes of V2 checkpoints to merge.
-///   - destination_prefix: scalar.  The desired final prefix.  Allowed to be the same
-///     as one of the checkpoint_prefixes.
-///
-/// - Attr delete_old_dirs: see above.
-@inlinable
-public static func mergeV2Checkpoints(
-  checkpointPrefixes: StringTensor,
-  destinationPrefix: StringTensor,
-  deleteOldDirs: Bool = true
-) {
-  let op = TFE_Op("MergeV2Checkpoints")
-  op.setAttr("delete_old_dirs", deleteOldDirs)
-  let _ = op.addInput(checkpointPrefixes)
-  let _ = op.addInput(destinationPrefix)
-  op.execute()
-}
-
-/// Transforms a spectrogram into a form that's useful for speech recognition.
-///
-/// Mel Frequency Cepstral Coefficients are a way of representing audio data that's
-/// been effective as an input feature for machine learning. They are created by
-/// taking the spectrum of a spectrogram (a 'cepstrum'), and discarding some of the
-/// higher frequencies that are less significant to the human ear. They have a long
-/// history in the speech recognition world, and https://en.wikipedia.org/wiki/Mel-frequency_cepstrum
-/// is a good resource to learn more.
-///
-/// - Parameters:
-///   - spectrogram: Typically produced by the Spectrogram op, with magnitude_squared
-///     set to true.
-///   - sample_rate: How many samples per second the source audio used.
-///
-/// - Attrs:
-///   - upper_frequency_limit: The highest frequency to use when calculating the
-///     ceptstrum.
-///   - lower_frequency_limit: The lowest frequency to use when calculating the
-///     ceptstrum.
-///   - filterbank_channel_count: Resolution of the Mel bank used internally.
-///   - dct_coefficient_count: How many output channels to produce per time slice.
-@inlinable
-public static func mfcc(
-  spectrogram: Tensor<Float>,
-  sampleRate: Tensor<Int32>,
-  upperFrequencyLimit: Double = 4000,
-  lowerFrequencyLimit: Double = 20,
-  filterbankChannelCount: Int64 = 40,
-  dctCoefficientCount: Int64 = 13
-) -> Tensor<Float> {
-  let op = TFE_Op("Mfcc")
-  op.setAttr("upper_frequency_limit", upperFrequencyLimit)
-  op.setAttr("lower_frequency_limit", lowerFrequencyLimit)
-  op.setAttr("filterbank_channel_count", filterbankChannelCount)
-  op.setAttr("dct_coefficient_count", dctCoefficientCount)
-  let _ = op.addInput(spectrogram)
-  let _ = op.addInput(sampleRate)
-  return op.execute(Int(1))
-}
-
-/// Computes the minimum of elements across dimensions of a tensor.
-///
-/// Reduces `input` along the dimensions given in `axis`. Unless
-/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-/// `axis`. If `keep_dims` is true, the reduced dimensions are
-/// retained with length 1.
-///
-/// - Parameters:
-///   - input: The tensor to reduce.
-///   - reduction_indices: The dimensions to reduce. Must be in the range
-///     `[-rank(input), rank(input))`.
-///
-/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-///
-/// - Output output: The reduced tensor.
-@inlinable
-public static func min<
-    T: Numeric & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  reductionIndices: Tensor<Tidx>,
-  keepDims: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("Min")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(reductionIndices)
-  return op.execute(Int(1))
-}
-
-/// Returns the min of x and y (i.e. x < y ? x : y) element-wise.
-///
-/// *NOTE*: `Minimum` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func minimum<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Minimum")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Pads a tensor with mirrored values.
-///
-/// This operation pads a `input` with mirrored values according to the `paddings`
-/// you specify. `paddings` is an integer tensor with shape `[n, 2]`, where n is
-/// the rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
-/// how many values to add before the contents of `input` in that dimension, and
-/// `paddings[D, 1]` indicates how many values to add after the contents of `input`
-/// in that dimension. Both `paddings[D, 0]` and `paddings[D, 1]` must be no greater
-/// than `input.dim_size(D)` (or `input.dim_size(D) - 1`) if `copy_border` is true
-/// (if false, respectively).
-///
-/// The padded size of each dimension D of the output is:
-///
-/// `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
-///
-/// For example:
-///
-/// ```
-/// # 't' is [[1, 2, 3], [4, 5, 6]].
-/// # 'paddings' is [[1, 1]], [2, 2]].
-/// # 'mode' is SYMMETRIC.
-/// # rank of 't' is 2.
-/// pad(t, paddings) ==> [[2, 1, 1, 2, 3, 3, 2]
-///                       [2, 1, 1, 2, 3, 3, 2]
-///                       [5, 4, 4, 5, 6, 6, 5]
-///                       [5, 4, 4, 5, 6, 6, 5]]
-/// ```
-///
-/// - Parameters:
-///   - input: The input tensor to be padded.
-///   - paddings: A two-column matrix specifying the padding sizes. The number of
-///     rows must be the same as the rank of `input`.
-///
-/// - Attr mode: Either `REFLECT` or `SYMMETRIC`. In reflect mode the padded regions
-///   do not include the borders, while in symmetric mode the padded regions
-///   do include the borders. For example, if `input` is `[1, 2, 3]` and `paddings`
-///   is `[0, 2]`, then the output is `[1, 2, 3, 2, 1]` in reflect mode, and
-///   it is `[1, 2, 3, 3, 2]` in symmetric mode.
-///
-/// - Output output: The padded tensor.
-@inlinable
-public static func mirrorPad<
-    T: TensorFlowScalar,
-    Tpaddings: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  paddings: Tensor<Tpaddings>,
-  mode: Mode5
-) -> Tensor<T> {
-  let op = TFE_Op("MirrorPad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tpaddings", Tpaddings.tensorFlowDataType)
-  op.setAttr("mode", mode.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(paddings)
-  return op.execute(Int(1))
-}
-
-/// Gradient op for `MirrorPad` op. This op folds a mirror-padded tensor.
-///
-/// This operation folds the padded areas of `input` by `MirrorPad` according to the
-/// `paddings` you specify. `paddings` must be the same as `paddings` argument
-/// given to the corresponding `MirrorPad` op.
-///
-/// The folded size of each dimension D of the output is:
-///
-/// `input.dim_size(D) - paddings(D, 0) - paddings(D, 1)`
-///
-/// For example:
-///
-/// ```
-/// # 't' is [[1, 2, 3], [4, 5, 6], [7, 8, 9]].
-/// # 'paddings' is [[0, 1]], [0, 1]].
-/// # 'mode' is SYMMETRIC.
-/// # rank of 't' is 2.
-/// pad(t, paddings) ==> [[ 1,  5]
-///                       [11, 28]]
-/// ```
-///
-/// - Parameters:
-///   - input: The input tensor to be folded.
-///   - paddings: A two-column matrix specifying the padding sizes. The number of
-///     rows must be the same as the rank of `input`.
-///
-/// - Attr mode: The mode used in the `MirrorPad` op.
-///
-/// - Output output: The folded tensor.
-@inlinable
-public static func mirrorPadGrad<
-    T: TensorFlowScalar,
-    Tpaddings: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  paddings: Tensor<Tpaddings>,
-  mode: Mode5
-) -> Tensor<T> {
-  let op = TFE_Op("MirrorPadGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tpaddings", Tpaddings.tensorFlowDataType)
-  op.setAttr("mode", mode.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(paddings)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func mixedStruct(
-  nA: Int64
-) -> (a: [Tensor<Int32>], b: Tensor<Float>) {
-  let op = TFE_Op("MixedStruct")
-  op.setAttr("n_a", nA)
-  return op.execute(Int(nA), Int(1))
-}
-
-/// Returns element-wise remainder of division. This emulates C semantics in that
-///
-/// the result here is consistent with a truncating divide. E.g.
-/// `tf.truncatediv(x, y) * y + truncate_mod(x, y) = x`.
-///
-/// *NOTE*: `Mod` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func mod<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Mod")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Identity transformation that models performance.
-///
-/// Identity transformation that models performance.
-///
-/// - Parameter input_dataset: A variant tensor representing the input dataset.
-@inlinable
-public static func modelDataset(
-  inputDataset: VariantHandle,
-  cpuBudget: Int64 = 0,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ModelDataset")
-  op.setAttr("cpu_budget", cpuBudget)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  return op.execute(Int(1))
-}
-
-/// Returns x * y element-wise.
-///
-/// *NOTE*: `Multiply` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func mul<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Mul")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns x * y element-wise. Returns zero if y is zero, even if x if infinite or NaN.
-///
-/// *NOTE*: `Mul` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func mulNoNan<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("MulNoNan")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Creates a MultiDeviceIterator resource.
-///
-/// - Attrs:
-///   - devices: A list of devices the iterator works across.
-///   - shared_name: If non-empty, this resource will be shared under the given name
-///     across multiple sessions.
-///   - container: If non-empty, this resource is placed in the given container.
-///     Otherwise, a default container is used.
-///   - output_types: The type list for the return values.
-///   - output_shapes: The list of shapes being produced.
-///
-/// - Output handle: Handle to the resource created.
-@inlinable
-public static func multiDeviceIterator(
-  devices: [String],
-  sharedName: String,
-  container: String,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> ResourceHandle {
-  let op = TFE_Op("MultiDeviceIterator")
-  op.setAttr("devices", devices)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("container", container)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  return op.execute(Int(1))
-}
-
-/// Generates a MultiDeviceIterator resource from its provided string handle.
-///
-/// - Parameter string_handle: String representing the resource.
-///
-/// - Attrs:
-///   - output_types: The type list for the return values.
-///   - output_shapes: The list of shapes being produced.
-///
-/// - Output multi_device_iterator: A MultiDeviceIterator resource.
-@inlinable
-public static func multiDeviceIteratorFromStringHandle(
-  stringHandle: StringTensor,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> ResourceHandle {
-  let op = TFE_Op("MultiDeviceIteratorFromStringHandle")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(stringHandle)
-  return op.execute(Int(1))
-}
-
-/// Gets next element for the provided shard number.
-///
-/// - Parameters:
-///   - multi_device_iterator: A MultiDeviceIterator resource.
-///   - shard_num: Integer representing which shard to fetch data for.
-///   - incarnation_id: Which incarnation of the MultiDeviceIterator is running.
-///
-/// - Attrs:
-///   - output_types: The type list for the return values.
-///   - output_shapes: The list of shapes being produced.
-///
-/// - Output components: Result of the get_next on the dataset.
-@inlinable
-public static func multiDeviceIteratorGetNextFromShard<OutputTypes: TensorGroup>(
-  multiDeviceIterator: ResourceHandle,
-  shardNum: Tensor<Int32>,
-  incarnationId: Tensor<Int64>,
-  outputShapes: [TensorShape?]
-) -> OutputTypes {
-  let op = TFE_Op("MultiDeviceIteratorGetNextFromShard")
-  op.setAttr("output_types", OutputTypes._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(multiDeviceIterator)
-  let _ = op.addInput(shardNum)
-  let _ = op.addInput(incarnationId)
-  return op.execute(Int(OutputTypes._typeList.count))
-}
-
-/// Initializes the multi device iterator with the given dataset.
-///
-/// - Parameters:
-///   - dataset: Dataset to be iterated upon.
-///   - multi_device_iterator: A MultiDeviceIteratorResource.
-///   - max_buffer_size: The maximum size of the host side per device buffer to keep.
-///
-/// - Output incarnation_id: An int64 indicating which incarnation of the MultiDeviceIterator
-///   is running.
-@inlinable
-public static func multiDeviceIteratorInit(
-  dataset: VariantHandle,
-  multiDeviceIterator: ResourceHandle,
-  maxBufferSize: Tensor<Int64>
-) -> Tensor<Int64> {
-  let op = TFE_Op("MultiDeviceIteratorInit")
-  let _ = op.addInput(dataset)
-  let _ = op.addInput(multiDeviceIterator)
-  let _ = op.addInput(maxBufferSize)
-  return op.execute(Int(1))
-}
-
-/// Produces a string handle for the given MultiDeviceIterator.
-///
-/// - Parameter multi_device_iterator: A MultiDeviceIterator resource.
-///
-/// - Output string_handle: A string representing the resource.
-@inlinable
-public static func multiDeviceIteratorToStringHandle(
-  multiDeviceIterator: ResourceHandle
-) -> StringTensor {
-  let op = TFE_Op("MultiDeviceIteratorToStringHandle")
-  let _ = op.addInput(multiDeviceIterator)
-  return op.execute(Int(1))
-}
-
-/// Draws samples from a multinomial distribution.
-///
-/// - Parameters:
-///   - logits: 2-D Tensor with shape `[batch_size, num_classes]`.  Each slice `[i, :]`
-///     represents the unnormalized log probabilities for all classes.
-///   - num_samples: 0-D.  Number of independent samples to draw for each row slice.
-///
-/// - Attrs:
-///   - seed: If either seed or seed2 is set to be non-zero, the internal random number
-///     generator is seeded by the given seed.  Otherwise, a random seed is used.
-///   - seed2: A second seed to avoid seed collision.
-///
-/// - Output output: 2-D Tensor with shape `[batch_size, num_samples]`.  Each slice `[i, :]`
-///   contains the drawn class labels with range `[0, num_classes)`.
-@inlinable
-public static func multinomial<
-    T: Numeric & TensorFlowScalar,
-    OutputDtype: BinaryInteger & TensorFlowScalar
->(
-  logits: Tensor<T>,
-  numSamples: Tensor<Int32>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<OutputDtype> {
-  let op = TFE_Op("Multinomial")
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("output_dtype", OutputDtype.tensorFlowDataType)
-  let _ = op.addInput(logits)
-  let _ = op.addInput(numSamples)
-  return op.execute(Int(1))
-}
-
-/// Creates an empty hash table that uses tensors as the backing store.
-///
-/// It uses "open addressing" with quadratic reprobing to resolve
-/// collisions.
-///
-/// This op creates a mutable hash table, specifying the type of its keys and
-/// values. Each value must be a scalar. Data can be inserted into the table using
-/// the insert operations. It does not support the initialization operation.
-///
-/// - Parameter empty_key: The key used to represent empty key buckets internally. Must not
-///   be used in insert or lookup operations.
-///
-/// - Attrs:
-///   - container: If non-empty, this table is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this table is shared under the given name across
-///     multiple sessions.
-///   - key_dtype: Type of the table keys.
-///   - value_dtype: Type of the table values.
-///   - value_shape: The shape of each value.
-///   - initial_num_buckets: The initial number of hash table buckets. Must be a power
-///     to 2.
-///   - max_load_factor: The maximum ratio between number of entries and number of
-///     buckets before growing the table. Must be between 0 and 1.
-///
-/// - Output table_handle: Handle to a table.
-@inlinable
-public static func mutableDenseHashTableV2<KeyDtype: TensorFlowScalar>(
-  emptyKey: Tensor<KeyDtype>,
-  deletedKey: Tensor<KeyDtype>,
-  container: String,
-  sharedName: String,
-  useNodeNameSharing: Bool = false,
-  valueDtype: TensorDataType,
-  valueShape: TensorShape?,
-  initialNumBuckets: Int64 = 131072,
-  maxLoadFactor: Double = 0.8
-) -> ResourceHandle {
-  let op = TFE_Op("MutableDenseHashTableV2")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("use_node_name_sharing", useNodeNameSharing)
-  op.setAttr("key_dtype", KeyDtype.tensorFlowDataType)
-  op.setAttr("value_dtype", valueDtype)
-  op.setAttr("value_shape", valueShape)
-  op.setAttr("initial_num_buckets", initialNumBuckets)
-  op.setAttr("max_load_factor", maxLoadFactor)
-  let _ = op.addInput(emptyKey)
-  let _ = op.addInput(deletedKey)
-  return op.execute(Int(1))
-}
-
-/// Creates an empty hash table.
-///
-/// This op creates a mutable hash table, specifying the type of its keys and
-/// values. Each value must be a vector. Data can be inserted into the table using
-/// the insert operations. It does not support the initialization operation.
-///
-/// - Attrs:
-///   - container: If non-empty, this table is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this table is shared under the given name across
-///     multiple sessions.
-///   - key_dtype: Type of the table keys.
-///   - value_dtype: Type of the table values.
-///
-/// - Output table_handle: Handle to a table.
-@inlinable
-public static func mutableHashTableOfTensorsV2(
-  container: String,
-  sharedName: String,
-  useNodeNameSharing: Bool = false,
-  keyDtype: TensorDataType,
-  valueDtype: TensorDataType,
-  valueShape: TensorShape?
-) -> ResourceHandle {
-  let op = TFE_Op("MutableHashTableOfTensorsV2")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("use_node_name_sharing", useNodeNameSharing)
-  op.setAttr("key_dtype", keyDtype)
-  op.setAttr("value_dtype", valueDtype)
-  op.setAttr("value_shape", valueShape)
-  return op.execute(Int(1))
-}
-
-/// Creates an empty hash table.
-///
-/// This op creates a mutable hash table, specifying the type of its keys and
-/// values. Each value must be a scalar. Data can be inserted into the table using
-/// the insert operations. It does not support the initialization operation.
-///
-/// - Attrs:
-///   - container: If non-empty, this table is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this table is shared under the given name across
-///     multiple sessions.
-///   - use_node_name_sharing: If true and shared_name is empty, the table is shared
-///     using the node name.
-///   - key_dtype: Type of the table keys.
-///   - value_dtype: Type of the table values.
-///
-/// - Output table_handle: Handle to a table.
-@inlinable
-public static func mutableHashTableV2(
-  container: String,
-  sharedName: String,
-  useNodeNameSharing: Bool = false,
-  keyDtype: TensorDataType,
-  valueDtype: TensorDataType
-) -> ResourceHandle {
-  let op = TFE_Op("MutableHashTableV2")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("use_node_name_sharing", useNodeNameSharing)
-  op.setAttr("key_dtype", keyDtype)
-  op.setAttr("value_dtype", valueDtype)
-  return op.execute(Int(1))
-}
-
-/// Locks a mutex resource.  The output is the lock.  So long as the lock tensor
-///
-/// is alive, any other request to use `MutexLock` with this mutex will wait.
-///
-/// This is particularly useful for creating a critical section when used in
-/// conjunction with `MutexLockIdentity`:
-///
-/// ```python
-///
-/// mutex = mutex_v2(
-///   shared_name=handle_name, container=container, name=name)
-///
-/// def execute_in_critical_section(fn, *args, **kwargs):
-///   lock = gen_resource_variable_ops.mutex_lock(mutex)
-///
-///   with ops.control_dependencies([lock]):
-///     r = fn(*args, **kwargs)
-///
-///   with ops.control_dependencies(nest.flatten(r)):
-///     with ops.colocate_with(mutex):
-///       ensure_lock_exists = mutex_lock_identity(lock)
-///
-///     # Make sure that if any element of r is accessed, all of
-///     # them are executed together.
-///     r = nest.map_structure(tf.identity, r)
-///
-///   with ops.control_dependencies([ensure_lock_exists]):
-///     return nest.map_structure(tf.identity, r)
-/// ```
-///
-/// While `fn` is running in the critical section, no other functions which wish to
-/// use this critical section may run.
-///
-/// Often the use case is that two executions of the same graph, in parallel,
-/// wish to run `fn`; and we wish to ensure that only one of them executes
-/// at a time.  This is especially important if `fn` modifies one or more
-/// variables at a time.
-///
-/// It is also useful if two separate functions must share a resource, but we
-/// wish to ensure the usage is exclusive.
-///
-/// - Parameter mutex: The mutex resource to lock.
-///
-/// - Output mutex_lock: A tensor that keeps a shared pointer to a lock on the mutex;
-///   when the Tensor is destroyed, the use count on the shared pointer is decreased
-///   by 1.  When it reaches 0, the lock is released.
-@inlinable
-public static func mutexLock(
-  mutex: ResourceHandle
-) -> VariantHandle {
-  let op = TFE_Op("MutexLock")
-  let _ = op.addInput(mutex)
-  return op.execute(Int(1))
-}
-
-/// Creates a Mutex resource that can be locked by `MutexLock`.
-///
-/// - Attrs:
-///   - container: If non-empty, this variable is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this variable is named in the given bucket
-///     with this shared_name. Otherwise, the node name is used instead.
-///
-/// - Output resource: The mutex resource.
-@inlinable
-public static func mutexV2(
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("MutexV2")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func nInPolymorphicTwice<T: TensorFlowScalar>(
-  _ a: [Tensor<T>],
-  _ b: [Tensor<T>]
-) {
-  let op = TFE_Op("NInPolymorphicTwice")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("N", a.count)
-  let _ = op.addInputList(a)
-  let _ = op.addInputList(b)
-  op.execute()
-}
-
-@inlinable
-public static func nInTwice(
-  _ a: [Tensor<Int32>],
-  _ b: [StringTensor]
-) {
-  let op = TFE_Op("NInTwice")
-  op.setAttr("N", a.count)
-  let _ = op.addInputList(a)
-  let _ = op.addInputList(b)
-  op.execute()
-}
-
-@inlinable
-public static func nInTwoTypeVariables<
-    S: TensorFlowScalar,
-    T: TensorFlowScalar
->(
-  _ a: [Tensor<S>],
-  _ b: [Tensor<T>]
-) {
-  let op = TFE_Op("NInTwoTypeVariables")
-  op.setAttr("S", S.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("N", a.count)
-  let _ = op.addInputList(a)
-  let _ = op.addInputList(b)
-  op.execute()
-}
-
-@inlinable
-public static func nIntsIn(
-  _ a: [Tensor<Int32>]
-) {
-  let op = TFE_Op("NIntsIn")
-  op.setAttr("N", a.count)
-  let _ = op.addInputList(a)
-  op.execute()
-}
-
-@inlinable
-public static func nIntsOut(
-  n: Int64
-) -> [Tensor<Int32>] {
-  let op = TFE_Op("NIntsOut")
-  op.setAttr("N", n)
-  return op.execute(Int(n))
-}
-
-@inlinable
-public static func nIntsOutDefault(
-  n: Int64 = 3
-) -> [Tensor<Int32>] {
-  let op = TFE_Op("NIntsOutDefault")
-  op.setAttr("N", n)
-  return op.execute(Int(n))
-}
-
-@inlinable
-public static func nPolymorphicIn<T: TensorFlowScalar>(
-  _ a: [Tensor<T>]
-) {
-  let op = TFE_Op("NPolymorphicIn")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("N", a.count)
-  let _ = op.addInputList(a)
-  op.execute()
-}
-
-@inlinable
-public static func nPolymorphicOut<T: TensorFlowScalar>(
-  n: Int64
-) -> [Tensor<T>] {
-  let op = TFE_Op("NPolymorphicOut")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("N", n)
-  return op.execute(Int(n))
-}
-
-@inlinable
-public static func nPolymorphicOutDefault<T: TensorFlowScalar>(
-  n: Int64 = 2
-) -> [Tensor<T>] {
-  let op = TFE_Op("NPolymorphicOutDefault")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("N", n)
-  return op.execute(Int(n))
-}
-
-@inlinable
-public static func nPolymorphicRestrictIn<T: TensorFlowScalar>(
-  _ a: [Tensor<T>]
-) {
-  let op = TFE_Op("NPolymorphicRestrictIn")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("N", a.count)
-  let _ = op.addInputList(a)
-  op.execute()
-}
-
-@inlinable
-public static func nPolymorphicRestrictIn(
-  _ a: [StringTensor]
-) {
-  let op = TFE_Op("NPolymorphicRestrictIn")
-  op.setAttr("T", TensorDataType(TF_STRING))
-  op.setAttr("N", a.count)
-  let _ = op.addInputList(a)
-  op.execute()
-}
-
-@inlinable
-public static func nPolymorphicRestrictOut<T: TensorFlowScalar>(
-  n: Int64
-) -> [Tensor<T>] {
-  let op = TFE_Op("NPolymorphicRestrictOut")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("N", n)
-  return op.execute(Int(n))
-}
-
-@inlinable
-public static func nPolymorphicRestrictOut(
-  n: Int64
-) -> [StringTensor] {
-  let op = TFE_Op("NPolymorphicRestrictOut")
-  op.setAttr("T", TensorDataType(TF_STRING))
-  op.setAttr("N", n)
-  return op.execute(Int(n))
-}
-
-/// Outputs a tensor containing the reduction across all input tensors.
-///
-/// Outputs a tensor containing the reduction across all input tensors passed to ops
-/// within the same `shared_name.
-///
-/// The graph should be constructed so if one op runs with shared_name value `c`,
-/// then `num_devices` ops will run with shared_name value `c`.  Failure to do so
-/// will cause the graph execution to fail to complete.
-///
-/// input: the input to the reduction
-/// data: the value of the reduction across all `num_devices` devices.
-/// reduction: the reduction operation to perform.
-/// num_devices: The number of devices participating in this reduction.
-/// shared_name: Identifier that shared between ops of the same reduction.
-@inlinable
-public static func ncclAllReduce<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  reduction: Reduction,
-  numDevices: Int64,
-  sharedName: String
-) -> Tensor<T> {
-  let op = TFE_Op("NcclAllReduce")
-  op.setAttr("reduction", reduction.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("num_devices", numDevices)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Sends `input` to all devices that are connected to the output.
-///
-/// Sends `input` to all devices that are connected to the output.
-///
-/// The graph should be constructed so that all ops connected to the output have a
-/// valid device assignment, and the op itself is assigned one of these devices.
-///
-/// input: The input to the broadcast.
-/// output: The same as input.
-/// shape: The shape of the input tensor.
-///
-@inlinable
-public static func ncclBroadcast<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  shape: TensorShape?
-) -> Tensor<T> {
-  let op = TFE_Op("NcclBroadcast")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("shape", shape)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Reduces `input` from `num_devices` using `reduction` to a single device.
-///
-/// Reduces `input` from `num_devices` using `reduction` to a single device.
-///
-/// The graph should be constructed so that all inputs have a valid device
-/// assignment, and the op itself is assigned one of these devices.
-///
-/// input: The input to the reduction.
-/// data: the value of the reduction across all `num_devices` devices.
-/// reduction: the reduction operation to perform.
-@inlinable
-public static func ncclReduce<T: Numeric & TensorFlowScalar>(
-  _ input: [Tensor<T>],
-  reduction: Reduction
-) -> Tensor<T> {
-  let op = TFE_Op("NcclReduce")
-  op.setAttr("reduction", reduction.cName)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("num_devices", input.count)
-  let _ = op.addInputList(input)
-  return op.execute(Int(1))
-}
-
-/// Selects the k nearest centers for each point.
-///
-/// Rows of points are assumed to be input points. Rows of centers are assumed to be
-/// the list of candidate centers. For each point, the k centers that have least L2
-/// distance to it are computed.
-///
-/// - Parameters:
-///   - points: Matrix of shape (n, d). Rows are assumed to be input points.
-///   - centers: Matrix of shape (m, d). Rows are assumed to be centers.
-///   - k: Number of nearest centers to return for each point. If k is larger than m, then
-///     only m centers are returned.
-///
-/// - Outputs:
-///   - nearest_center_indices: Matrix of shape (n, min(m, k)). Each row contains the indices of the centers
-///     closest to the corresponding point, ordered by increasing distance.
-///   - nearest_center_distances: Matrix of shape (n, min(m, k)). Each row contains the squared L2 distance to the
-///     corresponding center in nearest_center_indices.
-@inlinable
-public static func nearestNeighbors(
-  points: Tensor<Float>,
-  centers: Tensor<Float>,
-  k: Tensor<Int64>
-) -> (nearestCenterIndices: Tensor<Int64>, nearestCenterDistances: Tensor<Float>) {
-  let op = TFE_Op("NearestNeighbors")
-  let _ = op.addInput(points)
-  let _ = op.addInput(centers)
-  let _ = op.addInput(k)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Computes numerical negative value element-wise.
-///
-/// I.e., \\(y = -x\\).
-@inlinable
-public static func neg<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Neg")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns the next representable value of `x1` in the direction of `x2`, element-wise.
-///
-/// This operation returns the same result as the C++ std::nextafter function.
-///
-/// It can also return a subnormal number.
-///
-/// @compatibility(cpp)
-/// Equivalent to C++ std::nextafter function.
-/// @end_compatibility
-@inlinable
-public static func nextAfter<T: FloatingPoint & TensorFlowScalar>(
-  x1: Tensor<T>,
-  x2: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("NextAfter")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x1)
-  let _ = op.addInput(x2)
-  return op.execute(Int(1))
-}
-
-/// Makes its input available to the next iteration.
-///
-/// - Parameter data: The tensor to be made available to the next iteration.
-///
-/// - Output output: The same tensor as `data`.
-@inlinable
-public static func nextIteration<T: TensorFlowScalar>(
-  data: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("NextIteration")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(data)
-  return op.execute(Int(1))
-}
-
-/// Does nothing. Only useful as a placeholder for control edges.
-@inlinable
-public static func noOp(
-) {
-  let op = TFE_Op("NoOp")
-  
-  op.execute()
-}
-
-/// Non-deterministically generates some integers.
-///
-/// This op may use some OS-provided source of non-determinism (e.g. an RNG), so each execution will give different results.
-///
-/// - Parameter shape: The shape of the output tensor.
-///
-/// - Attr dtype: The type of the output.
-///
-/// - Output output: Non-deterministic integer values with specified shape.
-@inlinable
-public static func nonDeterministicInts<
-    Dtype: TensorFlowScalar,
-    ShapeDtype: TensorFlowScalar
->(
-  shape: Tensor<ShapeDtype>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("NonDeterministicInts")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Greedily selects a subset of bounding boxes in descending order of score,
-///
-/// pruning away boxes that have high intersection-over-union (IOU) overlap
-/// with previously selected boxes.  Bounding boxes are supplied as
-/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
-/// diagonal pair of box corners and the coordinates can be provided as normalized
-/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
-/// is agnostic to where the origin is in the coordinate system.  Note that this
-/// algorithm is invariant to orthogonal transformations and translations
-/// of the coordinate system; thus translating or reflections of the coordinate
-/// system result in the same boxes being selected by the algorithm.
-/// The output of this operation is a set of integers indexing into the input
-/// collection of bounding boxes representing the selected boxes.  The bounding
-/// box coordinates corresponding to the selected indices can then be obtained
-/// using the `tf.gather operation`.  For example:
-///   selected_indices = tf.image.non_max_suppression(
-///       boxes, scores, max_output_size, iou_threshold)
-///   selected_boxes = tf.gather(boxes, selected_indices)
-///
-/// - Parameters:
-///   - boxes: A 2-D float tensor of shape `[num_boxes, 4]`.
-///   - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
-///     score corresponding to each box (each row of boxes).
-///   - max_output_size: A scalar integer tensor representing the maximum number of
-///     boxes to be selected by non max suppression.
-///
-/// - Attr iou_threshold: A float representing the threshold for deciding whether boxes
-///   overlap too much with respect to IOU.
-///
-/// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
-///   indices from the boxes tensor, where `M <= max_output_size`.
-@inlinable
-public static func nonMaxSuppression(
-  boxes: Tensor<Float>,
-  scores: Tensor<Float>,
-  maxOutputSize: Tensor<Int32>,
-  iouThreshold: Double = 0.5
-) -> Tensor<Int32> {
-  let op = TFE_Op("NonMaxSuppression")
-  op.setAttr("iou_threshold", iouThreshold)
-  let _ = op.addInput(boxes)
-  let _ = op.addInput(scores)
-  let _ = op.addInput(maxOutputSize)
-  return op.execute(Int(1))
-}
-
-/// Greedily selects a subset of bounding boxes in descending order of score,
-///
-/// pruning away boxes that have high intersection-over-union (IOU) overlap
-/// with previously selected boxes.  Bounding boxes are supplied as
-/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
-/// diagonal pair of box corners and the coordinates can be provided as normalized
-/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
-/// is agnostic to where the origin is in the coordinate system.  Note that this
-/// algorithm is invariant to orthogonal transformations and translations
-/// of the coordinate system; thus translating or reflections of the coordinate
-/// system result in the same boxes being selected by the algorithm.
-///
-/// The output of this operation is a set of integers indexing into the input
-/// collection of bounding boxes representing the selected boxes.  The bounding
-/// box coordinates corresponding to the selected indices can then be obtained
-/// using the `tf.gather operation`.  For example:
-///
-///   selected_indices = tf.image.non_max_suppression_v2(
-///       boxes, scores, max_output_size, iou_threshold)
-///   selected_boxes = tf.gather(boxes, selected_indices)
-///
-/// - Parameters:
-///   - boxes: A 2-D float tensor of shape `[num_boxes, 4]`.
-///   - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
-///     score corresponding to each box (each row of boxes).
-///   - max_output_size: A scalar integer tensor representing the maximum number of
-///     boxes to be selected by non max suppression.
-///   - iou_threshold: A 0-D float tensor representing the threshold for deciding whether
-///     boxes overlap too much with respect to IOU.
-///
-/// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
-///   indices from the boxes tensor, where `M <= max_output_size`.
-@inlinable
-public static func nonMaxSuppressionV2<T: FloatingPoint & TensorFlowScalar>(
-  boxes: Tensor<T>,
-  scores: Tensor<T>,
-  maxOutputSize: Tensor<Int32>,
-  iouThreshold: Tensor<Float>
-) -> Tensor<Int32> {
-  let op = TFE_Op("NonMaxSuppressionV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(boxes)
-  let _ = op.addInput(scores)
-  let _ = op.addInput(maxOutputSize)
-  let _ = op.addInput(iouThreshold)
-  return op.execute(Int(1))
-}
-
-/// Greedily selects a subset of bounding boxes in descending order of score,
-///
-/// pruning away boxes that have high intersection-over-union (IOU) overlap
-/// with previously selected boxes.  Bounding boxes with score less than
-/// `score_threshold` are removed.  Bounding boxes are supplied as
-/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
-/// diagonal pair of box corners and the coordinates can be provided as normalized
-/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
-/// is agnostic to where the origin is in the coordinate system and more
-/// generally is invariant to orthogonal transformations and translations
-/// of the coordinate system; thus translating or reflections of the coordinate
-/// system result in the same boxes being selected by the algorithm.
-/// The output of this operation is a set of integers indexing into the input
-/// collection of bounding boxes representing the selected boxes.  The bounding
-/// box coordinates corresponding to the selected indices can then be obtained
-/// using the `tf.gather operation`.  For example:
-///   selected_indices = tf.image.non_max_suppression_v2(
-///       boxes, scores, max_output_size, iou_threshold, score_threshold)
-///   selected_boxes = tf.gather(boxes, selected_indices)
-///
-/// - Parameters:
-///   - boxes: A 2-D float tensor of shape `[num_boxes, 4]`.
-///   - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
-///     score corresponding to each box (each row of boxes).
-///   - max_output_size: A scalar integer tensor representing the maximum number of
-///     boxes to be selected by non max suppression.
-///   - iou_threshold: A 0-D float tensor representing the threshold for deciding whether
-///     boxes overlap too much with respect to IOU.
-///   - score_threshold: A 0-D float tensor representing the threshold for deciding when to remove
-///     boxes based on score.
-///
-/// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
-///   indices from the boxes tensor, where `M <= max_output_size`.
-@inlinable
-public static func nonMaxSuppressionV3<T: FloatingPoint & TensorFlowScalar>(
-  boxes: Tensor<T>,
-  scores: Tensor<T>,
-  maxOutputSize: Tensor<Int32>,
-  iouThreshold: Tensor<Float>,
-  scoreThreshold: Tensor<Float>
-) -> Tensor<Int32> {
-  let op = TFE_Op("NonMaxSuppressionV3")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(boxes)
-  let _ = op.addInput(scores)
-  let _ = op.addInput(maxOutputSize)
-  let _ = op.addInput(iouThreshold)
-  let _ = op.addInput(scoreThreshold)
-  return op.execute(Int(1))
-}
-
-/// Greedily selects a subset of bounding boxes in descending order of score,
-///
-/// pruning away boxes that have high intersection-over-union (IOU) overlap
-/// with previously selected boxes.  Bounding boxes with score less than
-/// `score_threshold` are removed.  Bounding boxes are supplied as
-/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
-/// diagonal pair of box corners and the coordinates can be provided as normalized
-/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
-/// is agnostic to where the origin is in the coordinate system and more
-/// generally is invariant to orthogonal transformations and translations
-/// of the coordinate system; thus translating or reflections of the coordinate
-/// system result in the same boxes being selected by the algorithm.
-/// The output of this operation is a set of integers indexing into the input
-/// collection of bounding boxes representing the selected boxes.  The bounding
-/// box coordinates corresponding to the selected indices can then be obtained
-/// using the `tf.gather operation`.  For example:
-///   selected_indices = tf.image.non_max_suppression_v2(
-///       boxes, scores, max_output_size, iou_threshold, score_threshold)
-///   selected_boxes = tf.gather(boxes, selected_indices)
-///
-/// - Parameters:
-///   - boxes: A 2-D float tensor of shape `[num_boxes, 4]`.
-///   - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
-///     score corresponding to each box (each row of boxes).
-///   - max_output_size: A scalar integer tensor representing the maximum number of
-///     boxes to be selected by non max suppression.
-///   - iou_threshold: A 0-D float tensor representing the threshold for deciding whether
-///     boxes overlap too much with respect to IOU.
-///   - score_threshold: A 0-D float tensor representing the threshold for deciding when to remove
-///     boxes based on score.
-///
-/// - Attr pad_to_max_output_size: If true, the output `selected_indices` is padded to be of length
-///   `max_output_size`. Defaults to false.
-///
-/// - Outputs:
-///   - selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
-///     indices from the boxes tensor, where `M <= max_output_size`.
-///   - valid_outputs: A 0-D integer tensor representing the number of valid elements in
-///     `selected_indices`, with the valid elements appearing first.
-@inlinable
-public static func nonMaxSuppressionV4<T: FloatingPoint & TensorFlowScalar>(
-  boxes: Tensor<T>,
-  scores: Tensor<T>,
-  maxOutputSize: Tensor<Int32>,
-  iouThreshold: Tensor<Float>,
-  scoreThreshold: Tensor<Float>,
-  padToMaxOutputSize: Bool = false
-) -> (selectedIndices: Tensor<Int32>, validOutputs: Tensor<Int32>) {
-  let op = TFE_Op("NonMaxSuppressionV4")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("pad_to_max_output_size", padToMaxOutputSize)
-  let _ = op.addInput(boxes)
-  let _ = op.addInput(scores)
-  let _ = op.addInput(maxOutputSize)
-  let _ = op.addInput(iouThreshold)
-  let _ = op.addInput(scoreThreshold)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Greedily selects a subset of bounding boxes in descending order of score,
-///
-/// pruning away boxes that have high overlaps
-/// with previously selected boxes.  Bounding boxes with score less than
-/// `score_threshold` are removed. N-by-n overlap values are supplied as square matrix,
-/// which allows for defining a custom overlap criterium (eg. intersection over union,
-/// intersection over area, etc.).
-///
-/// The output of this operation is a set of integers indexing into the input
-/// collection of bounding boxes representing the selected boxes.  The bounding
-/// box coordinates corresponding to the selected indices can then be obtained
-/// using the `tf.gather operation`.  For example:
-///
-///   selected_indices = tf.image.non_max_suppression_with_overlaps(
-///       overlaps, scores, max_output_size, overlap_threshold, score_threshold)
-///   selected_boxes = tf.gather(boxes, selected_indices)
-///
-/// - Parameters:
-///   - overlaps: A 2-D float tensor of shape `[num_boxes, num_boxes]` representing
-///     the n-by-n box overlap values.
-///   - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
-///     score corresponding to each box (each row of boxes).
-///   - max_output_size: A scalar integer tensor representing the maximum number of
-///     boxes to be selected by non max suppression.
-///   - overlap_threshold: A 0-D float tensor representing the threshold for deciding whether
-///     boxes overlap too.
-///   - score_threshold: A 0-D float tensor representing the threshold for deciding when to remove
-///     boxes based on score.
-///
-/// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
-///   indices from the boxes tensor, where `M <= max_output_size`.
-@inlinable
-public static func nonMaxSuppressionWithOverlaps(
-  overlaps: Tensor<Float>,
-  scores: Tensor<Float>,
-  maxOutputSize: Tensor<Int32>,
-  overlapThreshold: Tensor<Float>,
-  scoreThreshold: Tensor<Float>
-) -> Tensor<Int32> {
-  let op = TFE_Op("NonMaxSuppressionWithOverlaps")
-  let _ = op.addInput(overlaps)
-  let _ = op.addInput(scores)
-  let _ = op.addInput(maxOutputSize)
-  let _ = op.addInput(overlapThreshold)
-  let _ = op.addInput(scoreThreshold)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func none(
-) {
-  let op = TFE_Op("None")
-  
-  op.execute()
-}
-
-/// Returns the truth value of (x != y) element-wise.
-///
-/// *NOTE*: `NotEqual` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func notEqual<T: TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<Bool> {
-  let op = TFE_Op("NotEqual")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns the truth value of (x != y) element-wise.
-///
-/// *NOTE*: `NotEqual` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func notEqual(
-  _ x: StringTensor,
-  _ y: StringTensor
-) -> Tensor<Bool> {
-  let op = TFE_Op("NotEqual")
-  op.setAttr("T", TensorDataType(TF_STRING))
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Finds values of the `n`-th order statistic for the last dimension.
-///
-/// If the input is a vector (rank-1), finds the entries which is the nth-smallest
-/// value in the vector and outputs their values as scalar tensor.
-///
-/// For matrices (resp. higher rank input), computes the entries which is the
-/// nth-smallest value in each row (resp. vector along the last dimension). Thus,
-///
-///     values.shape = input.shape[:-1]
-///
-/// - Parameters:
-///   - input: 1-D or higher with last dimension at least `n+1`.
-///   - n: 0-D. Position of sorted vector to select along the last dimension (along
-///     each row for matrices). Valid range of n is `[0, input.shape[:-1])`
-///
-/// - Attr reverse: When set to True, find the nth-largest value in the vector and vice
-///   versa.
-///
-/// - Output values: The `n`-th order statistic along each last dimensional slice.
-@inlinable
-public static func nthElement<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  n: Tensor<Int32>,
-  reverse: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("NthElement")
-  op.setAttr("reverse", reverse)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(n)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func old(
-) {
-  let op = TFE_Op("Old")
-  
-  op.execute()
-}
-
-/// Returns a one-hot tensor.
-///
-/// The locations represented by indices in `indices` take value `on_value`,
-/// while all other locations take value `off_value`.
-///
-/// If the input `indices` is rank `N`, the output will have rank `N+1`,
-/// The new axis is created at dimension `axis` (default: the new axis is
-/// appended at the end).
-///
-/// If `indices` is a scalar the output shape will be a vector of length `depth`.
-///
-/// If `indices` is a vector of length `features`, the output shape will be:
-/// ```
-///   features x depth if axis == -1
-///   depth x features if axis == 0
-/// ```
-///
-/// If `indices` is a matrix (batch) with shape `[batch, features]`,
-/// the output shape will be:
-/// ```
-///   batch x features x depth if axis == -1
-///   batch x depth x features if axis == 1
-///   depth x batch x features if axis == 0
-/// ```
-///
-///
-/// Examples
-/// =========
-///
-/// Suppose that
-/// ```
-///   indices = [0, 2, -1, 1]
-///   depth = 3
-///   on_value = 5.0
-///   off_value = 0.0
-///   axis = -1
-/// ```
-///
-/// Then output is `[4 x 3]`:
-/// ```
-/// output =
-///   [5.0 0.0 0.0]  // one_hot(0)
-///   [0.0 0.0 5.0]  // one_hot(2)
-///   [0.0 0.0 0.0]  // one_hot(-1)
-///   [0.0 5.0 0.0]  // one_hot(1)
-/// ```
-///
-/// Suppose that
-/// ```
-///   indices = [0, 2, -1, 1]
-///   depth = 3
-///   on_value = 0.0
-///   off_value = 3.0
-///   axis = 0
-/// ```
-///
-/// Then output is `[3 x 4]`:
-/// ```
-/// output =
-///   [0.0 3.0 3.0 3.0]
-///   [3.0 3.0 3.0 0.0]
-///   [3.0 3.0 3.0 3.0]
-///   [3.0 0.0 3.0 3.0]
-/// //  ^                one_hot(0)
-/// //      ^            one_hot(2)
-/// //          ^        one_hot(-1)
-/// //              ^    one_hot(1)
-/// ```
-///
-/// Suppose that
-/// ```
-///   indices = [[0, 2], [1, -1]]
-///   depth = 3
-///   on_value = 1.0
-///   off_value = 0.0
-///   axis = -1
-/// ```
-///
-/// Then output is `[2 x 2 x 3]`:
-/// ```
-/// output =
-///   [
-///     [1.0, 0.0, 0.0]  // one_hot(0)
-///     [0.0, 0.0, 1.0]  // one_hot(2)
-///   ][
-///     [0.0, 1.0, 0.0]  // one_hot(1)
-///     [0.0, 0.0, 0.0]  // one_hot(-1)
-///   ]
-/// ```
-///
-/// - Parameters:
-///   - indices: A tensor of indices.
-///   - depth: A scalar defining the depth of the one hot dimension.
-///   - on_value: A scalar defining the value to fill in output when `indices[j] = i`.
-///   - off_value: A scalar defining the value to fill in output when `indices[j] != i`.
-///
-/// - Attr axis: The axis to fill (default: -1, a new inner-most axis).
-///
-/// - Output output: The one-hot tensor.
-@inlinable
-public static func oneHot<
-    T: TensorFlowScalar,
-    Ti: BinaryInteger & TensorFlowScalar
->(
-  indices: Tensor<Ti>,
-  depth: Tensor<Int32>,
-  onValue: Tensor<T>,
-  offValue: Tensor<T>,
-  axis: Int64 = -1
-) -> Tensor<T> {
-  let op = TFE_Op("OneHot")
-  op.setAttr("axis", axis)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("TI", Ti.tensorFlowDataType)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(depth)
-  let _ = op.addInput(onValue)
-  let _ = op.addInput(offValue)
-  return op.execute(Int(1))
-}
-
-/// Makes a "one-shot" iterator that can be iterated only once.
-///
-/// A one-shot iterator bundles the logic for defining the dataset and
-/// the state of the iterator in a single op, which allows simple input
-/// pipelines to be defined without an additional initialization
-/// ("MakeIterator") step.
-///
-/// One-shot iterators have the following limitations:
-///
-/// * They do not support parameterization: all logic for creating the underlying
-///   dataset must be bundled in the `dataset_factory` function.
-/// * They are not resettable. Once a one-shot iterator reaches the end of its
-///   underlying dataset, subsequent "IteratorGetNext" operations on that
-///   iterator will always produce an `OutOfRange` error.
-///
-/// For greater flexibility, use "Iterator" and "MakeIterator" to define
-/// an iterator using an arbitrary subgraph, which may capture tensors
-/// (including fed values) as parameters, and which may be reset multiple
-/// times by rerunning "MakeIterator".
-///
-/// - Attr dataset_factory: A function of type `() -> DT_VARIANT`, where the returned
-///   DT_VARIANT is a dataset.
-///
-/// - Output handle: A handle to the iterator that can be passed to an "IteratorGetNext"
-///   op.
-@inlinable
-public static func oneShotIterator<DatasetfactoryIn: TensorGroup,
-    DatasetfactoryOut: TensorGroup>(
-  datasetFactory: (DatasetfactoryIn) -> DatasetfactoryOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?],
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("OneShotIterator")
-  op.setAttr("dataset_factory", datasetFactory)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Returns a tensor of ones with the same shape and type as x.
-///
-/// - Parameter x: a tensor of type T.
-///
-/// - Output y: a tensor of the same shape and type as x but filled with ones.
-@inlinable
-public static func onesLike<T: TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("OnesLike")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func opWithDefaultAttr(
-  defaultFloat: Double = 123
-) -> Tensor<Int32> {
-  let op = TFE_Op("OpWithDefaultAttr")
-  op.setAttr("default_float", defaultFloat)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func opWithFutureDefaultAttr(
-) {
-  let op = TFE_Op("OpWithFutureDefaultAttr")
-  
-  op.execute()
-}
-
-/// Creates a dataset by applying optimizations to `input_dataset`.
-///
-/// Creates a dataset by applying optimizations to `input_dataset`.
-///
-/// - Parameters:
-///   - input_dataset: A variant tensor representing the input dataset.
-///   - optimizations: A `tf.string` vector `tf.Tensor` identifying optimizations to use.
-@inlinable
-public static func optimizeDataset(
-  inputDataset: VariantHandle,
-  optimizations: StringTensor,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?],
-  optimizationConfigs: [String]
-) -> VariantHandle {
-  let op = TFE_Op("OptimizeDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("optimization_configs", optimizationConfigs)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(optimizations)
-  return op.execute(Int(1))
-}
-
-/// Constructs an Optional variant from a tuple of tensors.
-@inlinable
-public static func optionalFromValue<ToutputTypes: TensorArrayProtocol>(
-  components: ToutputTypes
-) -> VariantHandle {
-  let op = TFE_Op("OptionalFromValue")
-  op.setAttr("Toutput_types", components._typeList)
-  let _ = op.addInputList(components)
-  return op.execute(Int(1))
-}
-
-/// Returns the value stored in an Optional variant or raises an error if none exists.
-@inlinable
-public static func optionalGetValue<OutputTypes: TensorGroup>(
-  optional: VariantHandle,
-  outputShapes: [TensorShape?]
-) -> OutputTypes {
-  let op = TFE_Op("OptionalGetValue")
-  op.setAttr("output_types", OutputTypes._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(optional)
-  return op.execute(Int(OutputTypes._typeList.count))
-}
-
-/// Returns true if and only if the given Optional variant has a value.
-@inlinable
-public static func optionalHasValue(
-  optional: VariantHandle
-) -> Tensor<Bool> {
-  let op = TFE_Op("OptionalHasValue")
-  let _ = op.addInput(optional)
-  return op.execute(Int(1))
-}
-
-/// Creates an Optional variant with no value.
-@inlinable
-public static func optionalNone(
-) -> VariantHandle {
-  let op = TFE_Op("OptionalNone")
-  
-  return op.execute(Int(1))
-}
-
-/// Op removes all elements in the underlying container.
-@inlinable
-public static func orderedMapClear(
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  dtypes: [TensorDataType],
-  container: String,
-  sharedName: String
-) {
-  let op = TFE_Op("OrderedMapClear")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", dtypes)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.execute()
-}
-
-/// Op returns the number of incomplete elements in the underlying container.
-@inlinable
-public static func orderedMapIncompleteSize(
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  dtypes: [TensorDataType],
-  container: String,
-  sharedName: String
-) -> Tensor<Int32> {
-  let op = TFE_Op("OrderedMapIncompleteSize")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", dtypes)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Op peeks at the values at the specified key.  If the
-///
-/// underlying container does not contain this key
-/// this op will block until it does.   This Op is optimized for
-/// performance.
-@inlinable
-public static func orderedMapPeek<Dtypes: TensorGroup>(
-  key: Tensor<Int64>,
-  indices: Tensor<Int32>,
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  container: String,
-  sharedName: String
-) -> Dtypes {
-  let op = TFE_Op("OrderedMapPeek")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", Dtypes._typeList)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(key)
-  let _ = op.addInput(indices)
-  return op.execute(Int(Dtypes._typeList.count))
-}
-
-/// Op returns the number of elements in the underlying container.
-@inlinable
-public static func orderedMapSize(
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  dtypes: [TensorDataType],
-  container: String,
-  sharedName: String
-) -> Tensor<Int32> {
-  let op = TFE_Op("OrderedMapSize")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", dtypes)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Stage (key, values) in the underlying container which behaves like a ordered
-///
-/// associative container.   Elements are ordered by key.
-///
-/// - Parameters:
-///   - key: int64
-///   - values: a list of tensors
-///     dtypes A list of data types that inserted values should adhere to.
-///
-/// - Attrs:
-///   - capacity: Maximum number of elements in the Staging Area. If > 0, inserts
-///     on the container will block when the capacity is reached.
-///   - container: If non-empty, this queue is placed in the given container. Otherwise,
-///     a default container is used.
-///   - shared_name: It is necessary to match this name to the matching Unstage Op.
-@inlinable
-public static func orderedMapStage<FakeDtypes: TensorArrayProtocol>(
-  key: Tensor<Int64>,
-  indices: Tensor<Int32>,
-  _ values: FakeDtypes,
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  dtypes: [TensorDataType],
-  container: String,
-  sharedName: String
-) {
-  let op = TFE_Op("OrderedMapStage")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", dtypes)
-  op.setAttr("fake_dtypes", values._typeList)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(key)
-  let _ = op.addInput(indices)
-  let _ = op.addInputList(values)
-  op.execute()
-}
-
-/// Op removes and returns the values associated with the key
-///
-/// from the underlying container.   If the underlying container
-/// does not contain this key, the op will block until it does.
-@inlinable
-public static func orderedMapUnstage<Dtypes: TensorGroup>(
-  key: Tensor<Int64>,
-  indices: Tensor<Int32>,
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  container: String,
-  sharedName: String
-) -> Dtypes {
-  let op = TFE_Op("OrderedMapUnstage")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", Dtypes._typeList)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(key)
-  let _ = op.addInput(indices)
-  return op.execute(Int(Dtypes._typeList.count))
-}
-
-/// Op removes and returns the (key, value) element with the smallest
-///
-/// key from the underlying container.   If the underlying container
-/// does not contain elements, the op will block until it does.
-@inlinable
-public static func orderedMapUnstageNoKey<Dtypes: TensorGroup>(
-  indices: Tensor<Int32>,
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  container: String,
-  sharedName: String
-) -> (key: Tensor<Int64>, values: Dtypes) {
-  let op = TFE_Op("OrderedMapUnstageNoKey")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", Dtypes._typeList)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(indices)
-  return op.execute(Int(1), Int(Dtypes._typeList.count))
-}
-
-@inlinable
-public static func outT<T: TensorFlowScalar>(
-) -> Tensor<T> {
-  let op = TFE_Op("OutT")
-  op.setAttr("T", T.tensorFlowDataType)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func outTypeList<T: TensorGroup>(
-) -> T {
-  let op = TFE_Op("OutTypeList")
-  op.setAttr("T", T._typeList)
-  return op.execute(Int(T._typeList.count))
-}
-
-@inlinable
-public static func outTypeListRestrict<T: TensorGroup>(
-) -> T {
-  let op = TFE_Op("OutTypeListRestrict")
-  op.setAttr("t", T._typeList)
-  return op.execute(Int(T._typeList.count))
-}
-
-/// Retrieves a single tensor from the computation outfeed.
-///
-/// This operation will block indefinitely until data is available.
-///
-/// - Attrs:
-///   - dtype: The type of elements in the tensor.
-///   - shape: The shape of the tensor.
-///   - device_ordinal: The TPU device to use. This should be -1 when the Op
-///     is running on a TPU device, and >= 0 when the Op is running on the CPU
-///     device.
-///
-/// - Output output: A tensor that will be read from the device outfeed.
-@inlinable
-public static func outfeedDequeue<Dtype: TensorFlowScalar>(
-  shape: TensorShape?,
-  deviceOrdinal: Int64 = -1
-) -> Tensor<Dtype> {
-  let op = TFE_Op("OutfeedDequeue")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape", shape)
-  op.setAttr("device_ordinal", deviceOrdinal)
-  return op.execute(Int(1))
-}
-
-/// Retrieve multiple values from the computation outfeed.
-///
-/// This operation will block indefinitely until data is available. Output `i`
-/// corresponds to XLA tuple element `i`.
-///
-/// - Attrs:
-///   - dtypes: The element types of each element in `outputs`.
-///   - shapes: The shapes of each tensor in `outputs`.
-///   - device_ordinal: The TPU device to use. This should be -1 when the Op
-///     is running on a TPU device, and >= 0 when the Op is running on the CPU
-///     device.
-///
-/// - Output outputs: A list of tensors that will be read from the outfeed.
-@inlinable
-public static func outfeedDequeueTuple<Dtypes: TensorGroup>(
-  shapes: [TensorShape?],
-  deviceOrdinal: Int64 = -1
-) -> Dtypes {
-  let op = TFE_Op("OutfeedDequeueTuple")
-  op.setAttr("dtypes", Dtypes._typeList)
-  op.setAttr("shapes", shapes)
-  op.setAttr("device_ordinal", deviceOrdinal)
-  return op.execute(Int(Dtypes._typeList.count))
-}
-
-/// Enqueue a Tensor on the computation outfeed.
-///
-/// - Parameter input: A tensor that will be inserted into the outfeed queue.
-@inlinable
-public static func outfeedEnqueue<Dtype: TensorFlowScalar>(
-  _ input: Tensor<Dtype>
-) {
-  let op = TFE_Op("OutfeedEnqueue")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(input)
-  op.execute()
-}
-
-/// Enqueue multiple Tensor values on the computation outfeed.
-///
-/// - Parameter inputs: A list of tensors that will be inserted into the outfeed queue as an
-///   XLA tuple.
-@inlinable
-public static func outfeedEnqueueTuple<Dtypes: TensorArrayProtocol>(
-  inputs: Dtypes
-) {
-  let op = TFE_Op("OutfeedEnqueueTuple")
-  op.setAttr("dtypes", inputs._typeList)
-  let _ = op.addInputList(inputs)
-  op.execute()
-}
-
-/// Packs a list of `N` rank-`R` tensors into one rank-`(R+1)` tensor.
-///
-/// Packs the `N` tensors in `values` into a tensor with rank one higher than each
-/// tensor in `values`, by packing them along the `axis` dimension.
-/// Given a list of tensors of shape `(A, B, C)`;
-///
-/// if `axis == 0` then the `output` tensor will have the shape `(N, A, B, C)`.
-/// if `axis == 1` then the `output` tensor will have the shape `(A, N, B, C)`.
-/// Etc.
-///
-/// For example:
-///
-/// ```
-/// # 'x' is [1, 4]
-/// # 'y' is [2, 5]
-/// # 'z' is [3, 6]
-/// pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
-/// pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]]
-/// ```
-///
-/// This is the opposite of `unpack`.
-///
-/// - Parameter values: Must be of same shape and type.
-///
-/// - Attr axis: Dimension along which to pack.  Negative values wrap around, so the
-///   valid range is `[-(R+1), R+1)`.
-///
-/// - Output output: The packed tensor.
-@inlinable
-public static func pack<T: TensorFlowScalar>(
-  _ values: [Tensor<T>],
-  axis: Int64 = 0
-) -> Tensor<T> {
-  let op = TFE_Op("Pack")
-  op.setAttr("N", values.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("axis", axis)
-  let _ = op.addInputList(values)
-  return op.execute(Int(1))
-}
-
-/// Pads a tensor with zeros.
-///
-/// This operation pads a `input` with zeros according to the `paddings` you
-/// specify. `paddings` is an integer tensor with shape `[Dn, 2]`, where n is the
-/// rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
-/// how many zeros to add before the contents of `input` in that dimension, and
-/// `paddings[D, 1]` indicates how many zeros to add after the contents of `input`
-/// in that dimension.
-///
-/// The padded size of each dimension D of the output is:
-///
-/// `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
-///
-/// For example:
-///
-/// ```
-/// # 't' is [[1, 1], [2, 2]]
-/// # 'paddings' is [[1, 1], [2, 2]]
-/// # rank of 't' is 2
-/// pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
-///                       [0, 0, 1, 1, 0, 0]
-///                       [0, 0, 2, 2, 0, 0]
-///                       [0, 0, 0, 0, 0, 0]]
-/// ```
-///
-@inlinable
-public static func pad<
-    T: TensorFlowScalar,
-    Tpaddings: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  paddings: Tensor<Tpaddings>
-) -> Tensor<T> {
-  let op = TFE_Op("Pad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tpaddings", Tpaddings.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(paddings)
-  return op.execute(Int(1))
-}
-
-/// Pads a tensor.
-///
-/// This operation pads `input` according to the `paddings` and `constant_values`
-/// you specify. `paddings` is an integer tensor with shape `[Dn, 2]`, where n is
-/// the rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
-/// how many padding values to add before the contents of `input` in that dimension,
-/// and `paddings[D, 1]` indicates how many padding values to add after the contents
-/// of `input` in that dimension. `constant_values` is a scalar tensor of the same
-/// type as `input` that indicates the value to use for padding `input`.
-///
-/// The padded size of each dimension D of the output is:
-///
-/// `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
-///
-/// For example:
-///
-/// ```
-/// # 't' is [[1, 1], [2, 2]]
-/// # 'paddings' is [[1, 1], [2, 2]]
-/// # 'constant_values' is 0
-/// # rank of 't' is 2
-/// pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
-///                       [0, 0, 1, 1, 0, 0]
-///                       [0, 0, 2, 2, 0, 0]
-///                       [0, 0, 0, 0, 0, 0]]
-/// ```
-@inlinable
-public static func padV2<
-    T: TensorFlowScalar,
-    Tpaddings: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  paddings: Tensor<Tpaddings>,
-  constantValues: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("PadV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tpaddings", Tpaddings.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(paddings)
-  let _ = op.addInput(constantValues)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that batches and pads `batch_size` elements from the input.
-///
-/// - Parameters:
-///   - batch_size: A scalar representing the number of elements to accumulate in a
-///     batch.
-///   - padded_shapes: A list of int64 tensors representing the desired padded shapes
-///     of the corresponding output components. These shapes may be partially
-///     specified, using `-1` to indicate that a particular dimension should be
-///     padded to the maximum size of all batch elements.
-///   - padding_values: A list of scalars containing the padding value to use for
-///     each of the outputs.
-@inlinable
-public static func paddedBatchDataset<ToutputTypes: TensorArrayProtocol>(
-  inputDataset: VariantHandle,
-  batchSize: Tensor<Int64>,
-  paddedShapes: [Tensor<Int64>],
-  paddingValues: ToutputTypes,
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("PaddedBatchDataset")
-  op.setAttr("Toutput_types", paddingValues._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("N", paddedShapes.count)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(batchSize)
-  let _ = op.addInputList(paddedShapes)
-  let _ = op.addInputList(paddingValues)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that batches and pads `batch_size` elements from the input.
-///
-/// - Parameters:
-///   - batch_size: A scalar representing the number of elements to accumulate in a
-///     batch.
-///   - padded_shapes: A list of int64 tensors representing the desired padded shapes
-///     of the corresponding output components. These shapes may be partially
-///     specified, using `-1` to indicate that a particular dimension should be
-///     padded to the maximum size of all batch elements.
-///   - padding_values: A list of scalars containing the padding value to use for
-///     each of the outputs.
-///   - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
-///     is smaller than desired.
-@inlinable
-public static func paddedBatchDatasetV2<ToutputTypes: TensorArrayProtocol>(
-  inputDataset: VariantHandle,
-  batchSize: Tensor<Int64>,
-  paddedShapes: [Tensor<Int64>],
-  paddingValues: ToutputTypes,
-  dropRemainder: Tensor<Bool>,
-  parallelCopy: Bool = false,
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("PaddedBatchDatasetV2")
-  op.setAttr("parallel_copy", parallelCopy)
-  op.setAttr("Toutput_types", paddingValues._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("N", paddedShapes.count)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(batchSize)
-  let _ = op.addInputList(paddedShapes)
-  let _ = op.addInputList(paddingValues)
-  let _ = op.addInput(dropRemainder)
-  return op.execute(Int(1))
-}
-
-/// A queue that produces elements in first-in first-out order.
-///
-/// Variable-size shapes are allowed by setting the corresponding shape dimensions
-/// to 0 in the shape attr.  In this case DequeueMany will pad up to the maximum
-/// size of any given element in the minibatch.  See below for details.
-///
-/// - Attrs:
-///   - component_types: The type of each component in a value.
-///   - shapes: The shape of each component in a value. The length of this attr must
-///     be either 0 or the same as the length of component_types.
-///     Shapes of fixed rank but variable size are allowed by setting
-///     any shape dimension to -1.  In this case, the inputs' shape may vary along
-///     the given dimension, and DequeueMany will pad the given dimension with
-///     zeros up to the maximum shape of all elements in the given batch.
-///     If the length of this attr is 0, different queue elements may have
-///     different ranks and shapes, but only one element may be dequeued at a time.
-///   - capacity: The upper bound on the number of elements in this queue.
-///     Negative numbers mean no limit.
-///   - container: If non-empty, this queue is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this queue will be shared under the given name
-///     across multiple sessions.
-///
-/// - Output handle: The handle to the queue.
-@inlinable
-public static func paddingFIFOQueueV2(
-  componentTypes: [TensorDataType],
-  shapes: [TensorShape?],
-  capacity: Int64 = -1,
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("PaddingFIFOQueueV2")
-  op.setAttr("component_types", componentTypes)
-  op.setAttr("shapes", shapes)
-  op.setAttr("capacity", capacity)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Concatenates a list of `N` tensors along the first dimension.
-///
-/// The input tensors are all required to have size 1 in the first dimension.
-///
-/// For example:
-///
-/// ```
-/// # 'x' is [[1, 4]]
-/// # 'y' is [[2, 5]]
-/// # 'z' is [[3, 6]]
-/// parallel_concat([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
-/// ```
-///
-/// The difference between concat and parallel_concat is that concat requires all
-/// of the inputs be computed before the operation will begin but doesn't require
-/// that the input shapes be known during graph construction.  Parallel concat
-/// will copy pieces of the input into the output as they become available, in
-/// some situations this can provide a performance benefit.
-///
-/// - Parameter values: Tensors to be concatenated. All must have size 1 in the first dimension
-///   and same shape.
-///
-/// - Attr shape: the final shape of the result; should be equal to the shapes of any input
-///   but with the number of input values in the first dimension.
-///
-/// - Output output: The concatenated tensor.
-@inlinable
-public static func parallelConcat<T: TensorFlowScalar>(
-  _ values: [Tensor<T>],
-  shape: TensorShape?
-) -> Tensor<T> {
-  let op = TFE_Op("ParallelConcat")
-  op.setAttr("N", values.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("shape", shape)
-  let _ = op.addInputList(values)
-  return op.execute(Int(1))
-}
-
-/// Interleave the values from the `data` tensors into a single tensor.
-///
-/// Builds a merged tensor such that
-///
-/// ```python
-///     merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
-/// ```
-///
-/// For example, if each `indices[m]` is scalar or vector, we have
-///
-/// ```python
-///     # Scalar indices:
-///     merged[indices[m], ...] = data[m][...]
-///
-///     # Vector indices:
-///     merged[indices[m][i], ...] = data[m][i, ...]
-/// ```
-///
-/// Each `data[i].shape` must start with the corresponding `indices[i].shape`,
-/// and the rest of `data[i].shape` must be constant w.r.t. `i`.  That is, we
-/// must have `data[i].shape = indices[i].shape + constant`.  In terms of this
-/// `constant`, the output shape is
-///
-///     merged.shape = [max(indices)] + constant
-///
-/// Values may be merged in parallel, so if an index appears in both `indices[m][i]`
-/// and `indices[n][j]`, the result may be invalid. This differs from the normal
-/// DynamicStitch operator that defines the behavior in that case.
-///
-/// For example:
-///
-/// ```python
-///     indices[0] = 6
-///     indices[1] = [4, 1]
-///     indices[2] = [[5, 2], [0, 3]]
-///     data[0] = [61, 62]
-///     data[1] = [[41, 42], [11, 12]]
-///     data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
-///     merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
-///               [51, 52], [61, 62]]
-/// ```
-///
-/// This method can be used to merge partitions created by `dynamic_partition`
-/// as illustrated on the following example:
-///
-/// ```python
-///     # Apply function (increments x_i) on elements for which a certain condition
-///     # apply (x_i != -1 in this example).
-///     x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
-///     condition_mask=tf.not_equal(x,tf.constant(-1.))
-///     partitioned_data = tf.dynamic_partition(
-///         x, tf.cast(condition_mask, tf.int32) , 2)
-///     partitioned_data[1] = partitioned_data[1] + 1.0
-///     condition_indices = tf.dynamic_partition(
-///         tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
-///     x = tf.dynamic_stitch(condition_indices, partitioned_data)
-///     # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
-///     # unchanged.
-/// ```
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/DynamicStitch.png" alt>
-/// </div>
-@inlinable
-public static func parallelDynamicStitch<T: TensorFlowScalar>(
-  indices: [Tensor<Int32>],
-  data: [Tensor<T>]
-) -> Tensor<T> {
-  let op = TFE_Op("ParallelDynamicStitch")
-  op.setAttr("N", indices.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInputList(indices)
-  let _ = op.addInputList(data)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
-///
-/// - Attr f: A function mapping elements of `input_dataset`, concatenated with
-///   `other_arguments`, to a Dataset variant that contains elements matching
-///   `output_types` and `output_shapes`.
-@inlinable
-public static func parallelInterleaveDatasetV2<
-    FIn: TensorGroup,
-    FOut: TensorGroup,
-    Targuments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  otherArguments: Targuments,
-  cycleLength: Tensor<Int64>,
-  blockLength: Tensor<Int64>,
-  numParallelCalls: Tensor<Int64>,
-  f: (FIn) -> FOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?],
-  sloppy: Bool = false
-) -> VariantHandle {
-  let op = TFE_Op("ParallelInterleaveDatasetV2")
-  op.setAttr("f", f)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("sloppy", sloppy)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(otherArguments)
-  let _ = op.addInput(cycleLength)
-  let _ = op.addInput(blockLength)
-  let _ = op.addInput(numParallelCalls)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
-///
-/// Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
-/// to `num_parallel_calls` copies of `f` in parallel.
-///
-/// - Parameter num_parallel_calls: The number of concurrent invocations of `f` that process
-///   elements from `input_dataset` in parallel.
-@inlinable
-public static func parallelMapDataset<
-    FIn: TensorGroup,
-    FOut: TensorGroup,
-    Targuments: TensorArrayProtocol
->(
-  inputDataset: VariantHandle,
-  otherArguments: Targuments,
-  numParallelCalls: Tensor<Int32>,
-  f: (FIn) -> FOut,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?],
-  useInterOpParallelism: Bool = true,
-  sloppy: Bool = false,
-  preserveCardinality: Bool = false
-) -> VariantHandle {
-  let op = TFE_Op("ParallelMapDataset")
-  op.setAttr("f", f)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("use_inter_op_parallelism", useInterOpParallelism)
-  op.setAttr("sloppy", sloppy)
-  op.setAttr("preserve_cardinality", preserveCardinality)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(otherArguments)
-  let _ = op.addInput(numParallelCalls)
-  return op.execute(Int(1))
-}
-
-/// Outputs random values from a normal distribution. The parameters may each be a
-///
-/// scalar which applies to the entire output, or a vector of length shape[0] which
-/// stores the parameters for each batch.
-///
-/// - Parameters:
-///   - shape: The shape of the output tensor. Batches are indexed by the 0th dimension.
-///   - means: The mean parameter of each batch.
-///   - stdevs: The standard deviation parameter of each batch. Must be greater than 0.
-///   - minvals: The minimum cutoff. May be -infinity.
-///   - maxvals: The maximum cutoff. May be +infinity, and must be more than the minval
-///     for each batch.
-///
-/// - Attrs:
-///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: A second seed to avoid seed collision.
-///   - dtype: The type of the output.
-///
-/// - Output output: A matrix of shape num_batches x samples_per_batch, filled with random
-///   truncated normal values using the parameters for each row.
-@inlinable
-public static func parameterizedTruncatedNormal<
-    Dtype: FloatingPoint & TensorFlowScalar,
-    T: BinaryInteger & TensorFlowScalar
->(
-  shape: Tensor<T>,
-  means: Tensor<Dtype>,
-  stdevs: Tensor<Dtype>,
-  minvals: Tensor<Dtype>,
-  maxvals: Tensor<Dtype>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<Dtype> {
-  let op = TFE_Op("ParameterizedTruncatedNormal")
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(means)
-  let _ = op.addInput(stdevs)
-  let _ = op.addInput(minvals)
-  let _ = op.addInput(maxvals)
-  return op.execute(Int(1))
-}
-
-/// Transforms a vector of brain.Example protos (as strings) into typed tensors.
-///
-/// - Parameters:
-///   - serialized: A vector containing a batch of binary serialized Example protos.
-///   - names: A vector containing the names of the serialized protos.
-///     May contain, for example, table key (descriptive) names for the
-///     corresponding serialized protos.  These are purely useful for debugging
-///     purposes, and the presence of values here has no effect on the output.
-///     May also be an empty vector if no names are available.
-///     If non-empty, this vector must be the same length as "serialized".
-///   - sparse_keys: A list of Nsparse string Tensors (scalars).
-///     The keys expected in the Examples' features associated with sparse values.
-///   - dense_keys: A list of Ndense string Tensors (scalars).
-///     The keys expected in the Examples' features associated with dense values.
-///   - dense_defaults: A list of Ndense Tensors (some may be empty).
-///     dense_defaults[j] provides default values
-///     when the example's feature_map lacks dense_key[j].  If an empty Tensor is
-///     provided for dense_defaults[j], then the Feature dense_keys[j] is required.
-///     The input type is inferred from dense_defaults[j], even when it's empty.
-///     If dense_defaults[j] is not empty, and dense_shapes[j] is fully defined,
-///     then the shape of dense_defaults[j] must match that of dense_shapes[j].
-///     If dense_shapes[j] has an undefined major dimension (variable strides dense
-///     feature), dense_defaults[j] must contain a single element:
-///     the padding element.
-///
-/// - Attrs:
-///   - sparse_types: A list of Nsparse types; the data types of data in each Feature
-///     given in sparse_keys.
-///     Currently the ParseExample supports DT_FLOAT (FloatList),
-///     DT_INT64 (Int64List), and DT_STRING (BytesList).
-///   - dense_shapes: A list of Ndense shapes; the shapes of data in each Feature
-///     given in dense_keys.
-///     The number of elements in the Feature corresponding to dense_key[j]
-///     must always equal dense_shapes[j].NumEntries().
-///     If dense_shapes[j] == (D0, D1, ..., DN) then the shape of output
-///     Tensor dense_values[j] will be (|serialized|, D0, D1, ..., DN):
-///     The dense outputs are just the inputs row-stacked by batch.
-///     This works for dense_shapes[j] = (-1, D1, ..., DN).  In this case
-///     the shape of the output Tensor dense_values[j] will be
-///     (|serialized|, M, D1, .., DN), where M is the maximum number of blocks
-///     of elements of length D1 * .... * DN, across all minibatch entries
-///     in the input.  Any minibatch entry with less than M blocks of elements of
-///     length D1 * ... * DN will be padded with the corresponding default_value
-///     scalar element along the second dimension.
-@inlinable
-public static func parseExample<
-    SparseTypes: TensorGroup,
-    Tdense: TensorArrayProtocol
->(
-  serialized: StringTensor,
-  names: StringTensor,
-  sparseKeys: [StringTensor],
-  denseKeys: [StringTensor],
-  denseDefaults: Tdense,
-  denseShapes: [TensorShape?]
-) -> (sparseIndices: [Tensor<Int64>], sparseValues: SparseTypes, sparseShapes: [Tensor<Int64>], denseValues: Tdense) {
-  let op = TFE_Op("ParseExample")
-  op.setAttr("Nsparse", sparseKeys.count)
-  op.setAttr("Ndense", denseKeys.count)
-  op.setAttr("sparse_types", SparseTypes._typeList)
-  op.setAttr("Tdense", denseDefaults._typeList)
-  op.setAttr("dense_shapes", denseShapes)
-  let _ = op.addInput(serialized)
-  let _ = op.addInput(names)
-  let _ = op.addInputList(sparseKeys)
-  let _ = op.addInputList(denseKeys)
-  let _ = op.addInputList(denseDefaults)
-  return op.execute(Int(sparseKeys.count), Int(SparseTypes._typeList.count), Int(sparseKeys.count), Int(denseDefaults._typeList.count))
-}
-
-/// Transforms a vector of brain.SequenceExample protos (as strings) into typed tensors.
-///
-/// - Parameters:
-///   - serialized: A vector containing binary serialized SequenceExample protos.
-///   - debug_name: A vector containing the names of the serialized protos.
-///     May contain, for example, table key (descriptive) name for the
-///     corresponding serialized proto.  This is purely useful for debugging
-///     purposes, and the presence of values here has no effect on the output.
-///     May also be an empty vector if no name is available.
-///   - context_dense_defaults: A list of Ncontext_dense Tensors (some may be empty).
-///     context_dense_defaults[j] provides default values
-///     when the SequenceExample's context map lacks context_dense_key[j].
-///     If an empty Tensor is provided for context_dense_defaults[j],
-///     then the Feature context_dense_keys[j] is required.
-///     The input type is inferred from context_dense_defaults[j], even when it's
-///     empty.  If context_dense_defaults[j] is not empty, its shape must match
-///     context_dense_shapes[j].
-///
-/// - Attrs:
-///   - feature_list_dense_missing_assumed_empty: A vector listing the
-///     FeatureList keys which may be missing from the SequenceExamples.  If the
-///     associated FeatureList is missing, it is treated as empty.  By default,
-///     any FeatureList not listed in this vector must exist in the SequenceExamples.
-///   - context_sparse_keys: A list of Ncontext_sparse string Tensors (scalars).
-///     The keys expected in the Examples' features associated with context_sparse
-///     values.
-///   - context_dense_keys: A list of Ncontext_dense string Tensors (scalars).
-///     The keys expected in the SequenceExamples' context features associated with
-///     dense values.
-///   - feature_list_sparse_keys: A list of Nfeature_list_sparse string Tensors
-///     (scalars).  The keys expected in the FeatureLists associated with sparse
-///     values.
-///   - feature_list_dense_keys: A list of Nfeature_list_dense string Tensors (scalars).
-///     The keys expected in the SequenceExamples' feature_lists associated
-///     with lists of dense values.
-///   - context_sparse_types: A list of Ncontext_sparse types; the data types of data in
-///     each context Feature given in context_sparse_keys.
-///     Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
-///     DT_INT64 (Int64List), and DT_STRING (BytesList).
-///   - context_dense_shapes: A list of Ncontext_dense shapes; the shapes of data in
-///     each context Feature given in context_dense_keys.
-///     The number of elements in the Feature corresponding to context_dense_key[j]
-///     must always equal context_dense_shapes[j].NumEntries().
-///     The shape of context_dense_values[j] will match context_dense_shapes[j].
-///   - feature_list_sparse_types: A list of Nfeature_list_sparse types; the data types
-///     of data in each FeatureList given in feature_list_sparse_keys.
-///     Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
-///     DT_INT64 (Int64List), and DT_STRING (BytesList).
-///   - feature_list_dense_shapes: A list of Nfeature_list_dense shapes; the shapes of
-///     data in each FeatureList given in feature_list_dense_keys.
-///     The shape of each Feature in the FeatureList corresponding to
-///     feature_list_dense_key[j] must always equal
-///     feature_list_dense_shapes[j].NumEntries().
-@inlinable
-public static func parseSequenceExample<
-    ContextSparseTypes: TensorGroup,
-    TcontextDense: TensorArrayProtocol,
-    FeatureListDenseTypes: TensorGroup,
-    FeatureListSparseTypes: TensorGroup
->(
-  serialized: StringTensor,
-  debugName: StringTensor,
-  contextDenseDefaults: TcontextDense,
-  featureListDenseMissingAssumedEmpty: [String],
-  contextSparseKeys: [String],
-  contextDenseKeys: [String],
-  featureListSparseKeys: [String],
-  featureListDenseKeys: [String],
-  ncontextSparse: Int64 = 0,
-  ncontextDense: Int64 = 0,
-  nfeatureListSparse: Int64 = 0,
-  nfeatureListDense: Int64 = 0,
-  contextDenseShapes: [TensorShape?],
-  featureListDenseShapes: [TensorShape?]
-) -> (contextSparseIndices: [Tensor<Int64>], contextSparseValues: ContextSparseTypes, contextSparseShapes: [Tensor<Int64>], contextDenseValues: TcontextDense, featureListSparseIndices: [Tensor<Int64>], featureListSparseValues: FeatureListSparseTypes, featureListSparseShapes: [Tensor<Int64>], featureListDenseValues: FeatureListDenseTypes, featureListDenseLengths: [Tensor<Int64>]) {
-  let op = TFE_Op("ParseSequenceExample")
-  op.setAttr("feature_list_dense_missing_assumed_empty", featureListDenseMissingAssumedEmpty)
-  op.setAttr("context_sparse_keys", contextSparseKeys)
-  op.setAttr("context_dense_keys", contextDenseKeys)
-  op.setAttr("feature_list_sparse_keys", featureListSparseKeys)
-  op.setAttr("feature_list_dense_keys", featureListDenseKeys)
-  op.setAttr("Ncontext_sparse", ncontextSparse)
-  op.setAttr("Ncontext_dense", ncontextDense)
-  op.setAttr("Nfeature_list_sparse", nfeatureListSparse)
-  op.setAttr("Nfeature_list_dense", nfeatureListDense)
-  op.setAttr("context_sparse_types", ContextSparseTypes._typeList)
-  op.setAttr("Tcontext_dense", contextDenseDefaults._typeList)
-  op.setAttr("feature_list_dense_types", FeatureListDenseTypes._typeList)
-  op.setAttr("context_dense_shapes", contextDenseShapes)
-  op.setAttr("feature_list_sparse_types", FeatureListSparseTypes._typeList)
-  op.setAttr("feature_list_dense_shapes", featureListDenseShapes)
-  let _ = op.addInput(serialized)
-  let _ = op.addInput(debugName)
-  let _ = op.addInputList(contextDenseDefaults)
-  return op.execute(Int(ncontextSparse), Int(ContextSparseTypes._typeList.count), Int(ncontextSparse), Int(contextDenseDefaults._typeList.count), Int(nfeatureListSparse), Int(FeatureListSparseTypes._typeList.count), Int(nfeatureListSparse), Int(FeatureListDenseTypes._typeList.count), Int(nfeatureListDense))
-}
-
-/// Transforms a tf.Example proto (as a string) into typed tensors.
-///
-/// - Parameters:
-///   - serialized: A vector containing a batch of binary serialized Example protos.
-///   - dense_defaults: A list of Tensors (some may be empty), whose length matches
-///     the length of `dense_keys`. dense_defaults[j] provides default values
-///     when the example's feature_map lacks dense_key[j].  If an empty Tensor is
-///     provided for dense_defaults[j], then the Feature dense_keys[j] is required.
-///     The input type is inferred from dense_defaults[j], even when it's empty.
-///     If dense_defaults[j] is not empty, and dense_shapes[j] is fully defined,
-///     then the shape of dense_defaults[j] must match that of dense_shapes[j].
-///     If dense_shapes[j] has an undefined major dimension (variable strides dense
-///     feature), dense_defaults[j] must contain a single element:
-///     the padding element.
-///
-/// - Attrs:
-///   - num_sparse: The number of sparse features to be parsed from the example. This
-///     must match the lengths of `sparse_keys` and `sparse_types`.
-///   - sparse_keys: A list of `num_sparse` strings.
-///     The keys expected in the Examples' features associated with sparse values.
-///   - dense_keys: The keys expected in the Examples' features associated with dense
-///     values.
-///   - sparse_types: A list of `num_sparse` types; the data types of data in each
-///     Feature given in sparse_keys.
-///     Currently the ParseSingleExample op supports DT_FLOAT (FloatList),
-///     DT_INT64 (Int64List), and DT_STRING (BytesList).
-///   - Tdense: The data types of data in each Feature given in dense_keys.
-///     The length of this list must match the length of `dense_keys`.
-///     Currently the ParseSingleExample op supports DT_FLOAT (FloatList),
-///     DT_INT64 (Int64List), and DT_STRING (BytesList).
-///   - dense_shapes: The shapes of data in each Feature given in dense_keys.
-///     The length of this list must match the length of `dense_keys`.  The
-///     number of elements in the Feature corresponding to dense_key[j] must
-///     always equal dense_shapes[j].NumEntries().  If dense_shapes[j] ==
-///     (D0, D1, ..., DN) then the shape of output Tensor dense_values[j]
-///     will be (D0, D1, ..., DN): In the case dense_shapes[j] = (-1, D1,
-///     ..., DN), the shape of the output Tensor dense_values[j] will be (M,
-///     D1, .., DN), where M is the number of blocks of elements of length
-///     D1 * .... * DN, in the input.
-@inlinable
-public static func parseSingleExample<
-    SparseTypes: TensorGroup,
-    Tdense: TensorArrayProtocol
->(
-  serialized: StringTensor,
-  denseDefaults: Tdense,
-  numSparse: Int64,
-  sparseKeys: [String],
-  denseKeys: [String],
-  denseShapes: [TensorShape?]
-) -> (sparseIndices: [Tensor<Int64>], sparseValues: SparseTypes, sparseShapes: [Tensor<Int64>], denseValues: Tdense) {
-  let op = TFE_Op("ParseSingleExample")
-  op.setAttr("num_sparse", numSparse)
-  op.setAttr("sparse_keys", sparseKeys)
-  op.setAttr("dense_keys", denseKeys)
-  op.setAttr("sparse_types", SparseTypes._typeList)
-  op.setAttr("Tdense", denseDefaults._typeList)
-  op.setAttr("dense_shapes", denseShapes)
-  let _ = op.addInput(serialized)
-  let _ = op.addInputList(denseDefaults)
-  return op.execute(Int(numSparse), Int(SparseTypes._typeList.count), Int(numSparse), Int(denseDefaults._typeList.count))
-}
-
-/// Transforms a scalar brain.SequenceExample proto (as strings) into typed tensors.
-///
-/// - Parameters:
-///   - serialized: A scalar containing a binary serialized SequenceExample proto.
-///   - feature_list_dense_missing_assumed_empty: A vector listing the
-///     FeatureList keys which may be missing from the SequenceExample.  If the
-///     associated FeatureList is missing, it is treated as empty.  By default,
-///     any FeatureList not listed in this vector must exist in the SequenceExample.
-///   - context_sparse_keys: A list of Ncontext_sparse string Tensors (scalars).
-///     The keys expected in the Examples' features associated with context_sparse
-///     values.
-///   - context_dense_keys: A list of Ncontext_dense string Tensors (scalars).
-///     The keys expected in the SequenceExamples' context features associated with
-///     dense values.
-///   - feature_list_sparse_keys: A list of Nfeature_list_sparse string Tensors
-///     (scalars).  The keys expected in the FeatureLists associated with sparse
-///     values.
-///   - feature_list_dense_keys: A list of Nfeature_list_dense string Tensors (scalars).
-///     The keys expected in the SequenceExamples' feature_lists associated
-///     with lists of dense values.
-///   - context_dense_defaults: A list of Ncontext_dense Tensors (some may be empty).
-///     context_dense_defaults[j] provides default values
-///     when the SequenceExample's context map lacks context_dense_key[j].
-///     If an empty Tensor is provided for context_dense_defaults[j],
-///     then the Feature context_dense_keys[j] is required.
-///     The input type is inferred from context_dense_defaults[j], even when it's
-///     empty.  If context_dense_defaults[j] is not empty, its shape must match
-///     context_dense_shapes[j].
-///   - debug_name: A scalar containing the name of the serialized proto.
-///     May contain, for example, table key (descriptive) name for the
-///     corresponding serialized proto.  This is purely useful for debugging
-///     purposes, and the presence of values here has no effect on the output.
-///     May also be an empty scalar if no name is available.
-///
-/// - Attrs:
-///   - context_sparse_types: A list of Ncontext_sparse types; the data types of data in
-///     each context Feature given in context_sparse_keys.
-///     Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
-///     DT_INT64 (Int64List), and DT_STRING (BytesList).
-///   - context_dense_shapes: A list of Ncontext_dense shapes; the shapes of data in
-///     each context Feature given in context_dense_keys.
-///     The number of elements in the Feature corresponding to context_dense_key[j]
-///     must always equal context_dense_shapes[j].NumEntries().
-///     The shape of context_dense_values[j] will match context_dense_shapes[j].
-///   - feature_list_sparse_types: A list of Nfeature_list_sparse types; the data types
-///     of data in each FeatureList given in feature_list_sparse_keys.
-///     Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
-///     DT_INT64 (Int64List), and DT_STRING (BytesList).
-///   - feature_list_dense_shapes: A list of Nfeature_list_dense shapes; the shapes of
-///     data in each FeatureList given in feature_list_dense_keys.
-///     The shape of each Feature in the FeatureList corresponding to
-///     feature_list_dense_key[j] must always equal
-///     feature_list_dense_shapes[j].NumEntries().
-@inlinable
-public static func parseSingleSequenceExample<
-    ContextSparseTypes: TensorGroup,
-    TcontextDense: TensorArrayProtocol,
-    FeatureListDenseTypes: TensorGroup,
-    FeatureListSparseTypes: TensorGroup
->(
-  serialized: StringTensor,
-  featureListDenseMissingAssumedEmpty: StringTensor,
-  contextSparseKeys: [StringTensor],
-  contextDenseKeys: [StringTensor],
-  featureListSparseKeys: [StringTensor],
-  featureListDenseKeys: [StringTensor],
-  contextDenseDefaults: TcontextDense,
-  debugName: StringTensor,
-  contextDenseShapes: [TensorShape?],
-  featureListDenseShapes: [TensorShape?]
-) -> (contextSparseIndices: [Tensor<Int64>], contextSparseValues: ContextSparseTypes, contextSparseShapes: [Tensor<Int64>], contextDenseValues: TcontextDense, featureListSparseIndices: [Tensor<Int64>], featureListSparseValues: FeatureListSparseTypes, featureListSparseShapes: [Tensor<Int64>], featureListDenseValues: FeatureListDenseTypes) {
-  let op = TFE_Op("ParseSingleSequenceExample")
-  op.setAttr("Ncontext_sparse", contextSparseKeys.count)
-  op.setAttr("Ncontext_dense", contextDenseKeys.count)
-  op.setAttr("Nfeature_list_sparse", featureListSparseKeys.count)
-  op.setAttr("Nfeature_list_dense", featureListDenseKeys.count)
-  op.setAttr("context_sparse_types", ContextSparseTypes._typeList)
-  op.setAttr("Tcontext_dense", contextDenseDefaults._typeList)
-  op.setAttr("feature_list_dense_types", FeatureListDenseTypes._typeList)
-  op.setAttr("context_dense_shapes", contextDenseShapes)
-  op.setAttr("feature_list_sparse_types", FeatureListSparseTypes._typeList)
-  op.setAttr("feature_list_dense_shapes", featureListDenseShapes)
-  let _ = op.addInput(serialized)
-  let _ = op.addInput(featureListDenseMissingAssumedEmpty)
-  let _ = op.addInputList(contextSparseKeys)
-  let _ = op.addInputList(contextDenseKeys)
-  let _ = op.addInputList(featureListSparseKeys)
-  let _ = op.addInputList(featureListDenseKeys)
-  let _ = op.addInputList(contextDenseDefaults)
-  let _ = op.addInput(debugName)
-  return op.execute(Int(contextSparseKeys.count), Int(ContextSparseTypes._typeList.count), Int(contextSparseKeys.count), Int(contextDenseDefaults._typeList.count), Int(featureListSparseKeys.count), Int(FeatureListSparseTypes._typeList.count), Int(featureListSparseKeys.count), Int(FeatureListDenseTypes._typeList.count))
-}
-
-/// Transforms a serialized tensorflow.TensorProto proto into a Tensor.
-///
-/// - Parameter serialized: A scalar string containing a serialized TensorProto proto.
-///
-/// - Attr out_type: The type of the serialized tensor.  The provided type must match the
-///   type of the serialized tensor and no implicit conversion will take place.
-///
-/// - Output output: A Tensor of type `out_type`.
-@inlinable
-public static func parseTensor<OutType: TensorFlowScalar>(
-  serialized: StringTensor
-) -> Tensor<OutType> {
-  let op = TFE_Op("ParseTensor")
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(serialized)
-  return op.execute(Int(1))
-}
-
-/// returns `f(inputs)`, where `f`'s body is placed and partitioned.
-///
-/// - Parameter args: A list of input tensors.
-///
-/// - Attrs:
-///   - Tin: A list of input types.
-///   - Tout: A list of output types.
-///   - f:       A function that takes 'args', a list of tensors, and returns 'output',
-///           another list of tensors. Input and output types are specified by 'Tin'
-///           and 'Tout'. The function body of f will be placed and partitioned across
-///           devices, setting this op apart from the regular Call op.
-///
-/// - Output output: A list of return values.
-@inlinable
-public static func partitionedCall<
-    Tin: TensorArrayProtocol,
-    Tout: TensorGroup,
-    FIn: TensorGroup,
-    FOut: TensorGroup
->(
-  args: Tin,
-  f: (FIn) -> FOut,
-  config: String,
-  configProto: String,
-  executorType: String
-) -> Tout {
-  let op = TFE_Op("PartitionedCall")
-  op.setAttr("Tin", args._typeList)
-  op.setAttr("Tout", Tout._typeList)
-  op.setAttr("f", f)
-  op.setAttr("config", config)
-  op.setAttr("config_proto", configProto)
-  op.setAttr("executor_type", executorType)
-  let _ = op.addInputList(args)
-  return op.execute(Int(Tout._typeList.count))
-}
-
-/// A placeholder op for a value that will be fed into the computation.
-///
-/// N.B. This operation will fail with an error if it is executed. It is
-/// intended as a way to represent a value that will always be fed, and to
-/// provide attrs that enable the fed value to be checked at runtime.
-///
-/// - Attrs:
-///   - dtype: The type of elements in the tensor.
-///   - shape: (Optional) The shape of the tensor. If the shape has 0 dimensions, the
-///     shape is unconstrained.
-///
-/// - Output output: A placeholder tensor that must be replaced using the feed mechanism.
-@inlinable
-public static func placeholder<Dtype: TensorFlowScalar>(
-  shape: TensorShape?
-) -> Tensor<Dtype> {
-  let op = TFE_Op("Placeholder")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape", shape)
-  return op.execute(Int(1))
-}
-
-/// A placeholder op for a value that will be fed into the computation.
-///
-/// N.B. This operation will fail with an error if it is executed. It is
-/// intended as a way to represent a value that will always be fed, and to
-/// provide attrs that enable the fed value to be checked at runtime.
-///
-/// - Attrs:
-///   - dtype: The type of elements in the tensor.
-///   - shape: The shape of the tensor. The shape can be any partially-specified
-///     shape.  To be unconstrained, pass in a shape with unknown rank.
-///
-/// - Output output: A placeholder tensor that must be replaced using the feed mechanism.
-@inlinable
-public static func placeholderV2<Dtype: TensorFlowScalar>(
-  shape: TensorShape?
-) -> Tensor<Dtype> {
-  let op = TFE_Op("PlaceholderV2")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape", shape)
-  return op.execute(Int(1))
-}
-
-/// A placeholder op that passes through `input` when its output is not fed.
-///
-/// - Parameter input: The default value to produce when `output` is not fed.
-///
-/// - Attrs:
-///   - dtype: The type of elements in the tensor.
-///   - shape: The (possibly partial) shape of the tensor.
-///
-/// - Output output: A placeholder tensor that defaults to `input` if it is not fed.
-@inlinable
-public static func placeholderWithDefault<Dtype: TensorFlowScalar>(
-  _ input: Tensor<Dtype>,
-  shape: TensorShape?
-) -> Tensor<Dtype> {
-  let op = TFE_Op("PlaceholderWithDefault")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape", shape)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Compute the polygamma function \\(\psi^{(n)}(x)\\).
-///
-/// The polygamma function is defined as:
-///
-///
-/// \\(\psi^{(a)}(x) = \frac{d^a}{dx^a} \psi(x)\\)
-///
-/// where \\(\psi(x)\\) is the digamma function.
-/// The polygamma function is defined only for non-negative integer orders \\a\\.
-@inlinable
-public static func polygamma<T: FloatingPoint & TensorFlowScalar>(
-  _ a: Tensor<T>,
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Polygamma")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func polymorphic<T: TensorFlowScalar>(
-  _ a: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Polymorphic")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func polymorphicDefaultOut<T: TensorFlowScalar>(
-) -> Tensor<T> {
-  let op = TFE_Op("PolymorphicDefaultOut")
-  op.setAttr("T", T.tensorFlowDataType)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func polymorphicOut<T: TensorFlowScalar>(
-) -> Tensor<T> {
-  let op = TFE_Op("PolymorphicOut")
-  op.setAttr("T", T.tensorFlowDataType)
-  return op.execute(Int(1))
-}
-
-/// Computes element-wise population count (a.k.a. popcount, bitsum, bitcount).
-///
-/// For each entry in `x`, calculates the number of `1` (on) bits in the binary
-/// representation of that entry.
-///
-/// **NOTE**: It is more efficient to first `tf.bitcast` your tensors into
-/// `int32` or `int64` and perform the bitcount on the result, than to feed in
-/// 8- or 16-bit inputs and then aggregate the resulting counts.
-@inlinable
-public static func populationCount<T: BinaryInteger & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<UInt8> {
-  let op = TFE_Op("PopulationCount")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the power of one value to another.
-///
-/// Given a tensor `x` and a tensor `y`, this operation computes \\(x^y\\) for
-/// corresponding elements in `x` and `y`. For example:
-///
-/// ```
-/// # tensor 'x' is [[2, 2]], [3, 3]]
-/// # tensor 'y' is [[8, 16], [2, 3]]
-/// tf.pow(x, y) ==> [[256, 65536], [9, 27]]
-/// ```
-@inlinable
-public static func pow<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Pow")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that asynchronously prefetches elements from `input_dataset`.
-///
-/// - Parameter buffer_size: The maximum number of elements to buffer in an iterator over
-///   this dataset.
-@inlinable
-public static func prefetchDataset(
-  inputDataset: VariantHandle,
-  bufferSize: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("PrefetchDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(bufferSize)
-  return op.execute(Int(1))
-}
-
-/// An op which linearizes one Tensor value to an opaque variant tensor.
-///
-/// - Parameter input: A tensor that will be linearized.
-///
-/// - Attrs:
-///   - dtype: The type of elements in the tensor.
-///   - shape: The shape of the tensor.
-///   - layout: A vector holding the requested layout in minor-to-major sequence. If a layout
-///     attribute is passed but its values are all -1 the layout will be computed by
-///     the infeed operation.
-@inlinable
-public static func prelinearize<Dtype: TensorFlowScalar>(
-  _ input: Tensor<Dtype>,
-  shape: TensorShape?,
-  layout: [Int32]
-) -> VariantHandle {
-  let op = TFE_Op("Prelinearize")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape", shape)
-  op.setAttr("layout", layout)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// An op which linearizes multiple Tensor values to an opaque variant tensor.
-///
-/// - Parameter inputs: A list of tensors that will be provided using the infeed mechanism.
-///
-/// - Attrs:
-///   - dtypes: The element types of each element in `inputs`.
-///   - shapes: The shapes of each tensor in `inputs`.
-///   - layouts: A vector holding the requested layout in minor-to-major sequence for all the
-///     tuple shapes in the order the shapes appear in the "shapes" input. The layout
-///     elements for a sub-shape can be set to -1 in which case the corresponding layout
-///     will be computed by the infeed operation.
-@inlinable
-public static func prelinearizeTuple<Dtypes: TensorArrayProtocol>(
-  inputs: Dtypes,
-  shapes: [TensorShape?],
-  layouts: [Int32]
-) -> VariantHandle {
-  let op = TFE_Op("PrelinearizeTuple")
-  op.setAttr("dtypes", inputs._typeList)
-  op.setAttr("shapes", shapes)
-  op.setAttr("layouts", layouts)
-  let _ = op.addInputList(inputs)
-  return op.execute(Int(1))
-}
-
-/// 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.
-///
-/// - Parameter input: any tensor.
-///
-/// - Attr message: Will be printed in the error when anyone tries to differentiate
-///   this operation.
-///
-/// - Output output: the same input tensor.
-@inlinable
-public static func preventGradient<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  message: String
-) -> Tensor<T> {
-  let op = TFE_Op("PreventGradient")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("message", message)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Prints a list of tensors.
-///
-/// Passes `input` through to `output` and prints `data` when evaluating.
-///
-/// - Parameters:
-///   - input: The tensor passed to `output`
-///   - data: A list of tensors to print out when op is evaluated.
-///
-/// - Attrs:
-///   - message: A string, prefix of the error message.
-///   - first_n: Only log `first_n` number of times. -1 disables logging.
-///   - summarize: Only print this many entries of each tensor.
-///
-/// - Output output: = The unmodified `input` tensor
-@inlinable
-public static func print<
-    T: TensorFlowScalar,
-    U: TensorArrayProtocol
->(
-  _ input: Tensor<T>,
-  data: U,
-  message: String,
-  firstN: Int64 = -1,
-  summarize: Int64 = 3
-) -> Tensor<T> {
-  let op = TFE_Op("Print")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("U", data._typeList)
-  op.setAttr("message", message)
-  op.setAttr("first_n", firstN)
-  op.setAttr("summarize", summarize)
-  let _ = op.addInput(input)
-  let _ = op.addInputList(data)
-  return op.execute(Int(1))
-}
-
-/// Prints a string scalar.
-///
-/// Prints a string scalar to the desired output_stream.
-///
-/// - Parameter input: The string scalar to print.
-///
-/// - Attr output_stream: A string specifying the output stream or logging level to print to.
-@inlinable
-public static func printV2(
-  _ input: StringTensor,
-  outputStream: String = "stderr"
-) {
-  let op = TFE_Op("PrintV2")
-  op.setAttr("output_stream", outputStream)
-  let _ = op.addInput(input)
-  op.execute()
-}
-
-/// A queue that produces elements sorted by the first component value.
-///
-/// Note that the PriorityQueue requires the first component of any element
-/// to be a scalar int64, in addition to the other elements declared by
-/// component_types.  Therefore calls to Enqueue and EnqueueMany (resp. Dequeue
-/// and DequeueMany) on a PriorityQueue will all require (resp. output) one extra
-/// entry in their input (resp. output) lists.
-///
-/// - Attrs:
-///   - component_types: The type of each component in a value.
-///   - shapes: The shape of each component in a value. The length of this attr must
-///     be either 0 or the same as the length of component_types. If the length of
-///     this attr is 0, the shapes of queue elements are not constrained, and
-///     only one element may be dequeued at a time.
-///   - capacity: The upper bound on the number of elements in this queue.
-///     Negative numbers mean no limit.
-///   - container: If non-empty, this queue is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this queue will be shared under the given name
-///     across multiple sessions.
-///
-/// - Output handle: The handle to the queue.
-@inlinable
-public static func priorityQueueV2(
-  componentTypes: [TensorDataType],
-  shapes: [TensorShape?],
-  capacity: Int64 = -1,
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("PriorityQueueV2")
-  op.setAttr("component_types", componentTypes)
-  op.setAttr("shapes", shapes)
-  op.setAttr("capacity", capacity)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Computes the product of elements across dimensions of a tensor.
-///
-/// Reduces `input` along the dimensions given in `axis`. Unless
-/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-/// `axis`. If `keep_dims` is true, the reduced dimensions are
-/// retained with length 1.
-///
-/// - Parameters:
-///   - input: The tensor to reduce.
-///   - reduction_indices: The dimensions to reduce. Must be in the range
-///     `[-rank(input), rank(input))`.
-///
-/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-///
-/// - Output output: The reduced tensor.
-@inlinable
-public static func prod<
-    T: Numeric & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  reductionIndices: Tensor<Tidx>,
-  keepDims: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("Prod")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(reductionIndices)
-  return op.execute(Int(1))
-}
-
-/// Invokes a python function to compute func(input)->output.
-///
-/// This operation is considered stateful. For a stateless version, see
-/// PyFuncStateless.
-///
-/// - Parameter input: List of Tensors that will provide input to the Op.
-///
-/// - Attrs:
-///   - token: A token representing a registered python function in this address space.
-///   - Tin: Data types of the inputs to the op.
-///   - Tout: Data types of the outputs from the op.
-///     The length of the list specifies the number of outputs.
-///
-/// - Output output: The outputs from the Op.
-@inlinable
-public static func pyFunc<
-    Tin: TensorArrayProtocol,
-    Tout: TensorGroup
->(
-  _ input: Tin,
-  token: String
-) -> Tout {
-  let op = TFE_Op("PyFunc")
-  op.setAttr("token", token)
-  op.setAttr("Tin", input._typeList)
-  op.setAttr("Tout", Tout._typeList)
-  let _ = op.addInputList(input)
-  return op.execute(Int(Tout._typeList.count))
-}
-
-/// A stateless version of PyFunc.
-@inlinable
-public static func pyFuncStateless<
-    Tin: TensorArrayProtocol,
-    Tout: TensorGroup
->(
-  _ input: Tin,
-  token: String
-) -> Tout {
-  let op = TFE_Op("PyFuncStateless")
-  op.setAttr("token", token)
-  op.setAttr("Tin", input._typeList)
-  op.setAttr("Tout", Tout._typeList)
-  let _ = op.addInputList(input)
-  return op.execute(Int(Tout._typeList.count))
-}
-
-/// Computes the QR decompositions of one or more matrices.
-///
-/// Computes the QR decomposition of each inner matrix in `tensor` such that
-/// `tensor[..., :, :] = q[..., :, :] * r[..., :,:])`
-///
-/// ```python
-/// # a is a tensor.
-/// # q is a tensor of orthonormal matrices.
-/// # r is a tensor of upper triangular matrices.
-/// q, r = qr(a)
-/// q_full, r_full = qr(a, full_matrices=True)
-/// ```
-///
-/// - Parameter input: A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
-///   form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
-///
-/// - Attr full_matrices: If true, compute full-sized `q` and `r`. If false
-///   (the default), compute only the leading `P` columns of `q`.
-///
-/// - Outputs:
-///   - q: Orthonormal basis for range of `a`. If `full_matrices` is `False` then
-///     shape is `[..., M, P]`; if `full_matrices` is `True` then shape is
-///     `[..., M, M]`.
-///   - r: Triangular factor. If `full_matrices` is `False` then shape is
-///     `[..., P, N]`. If `full_matrices` is `True` then shape is `[..., M, N]`.
-@inlinable
-public static func qr<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  fullMatrices: Bool = false
-) -> (q: Tensor<T>, r: Tensor<T>) {
-  let op = TFE_Op("Qr")
-  op.setAttr("full_matrices", fullMatrices)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Use QuantizeAndDequantizeV2 instead.
-@inlinable
-public static func quantizeAndDequantize<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  signedInput: Bool = true,
-  numBits: Int64 = 8,
-  rangeGiven: Bool = false,
-  inputMin: Double = 0,
-  inputMax: Double = 0
-) -> Tensor<T> {
-  let op = TFE_Op("QuantizeAndDequantize")
-  op.setAttr("signed_input", signedInput)
-  op.setAttr("num_bits", numBits)
-  op.setAttr("range_given", rangeGiven)
-  op.setAttr("input_min", inputMin)
-  op.setAttr("input_max", inputMax)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Quantizes then dequantizes a tensor.
-///
-/// This op simulates the precision loss from the quantized forward pass by:
-///
-/// 1. Quantizing the tensor to fixed point numbers, which should match the target
-///    quantization method when it is used in inference.
-/// 2. Dequantizing it back to floating point numbers for the following ops, most
-///    likely matmul.
-///
-/// There are different ways to quantize. This version uses only scaling, so 0.0
-/// maps to 0.
-///
-/// From the specified 'num_bits' in the quantized output type, it determines
-/// minimum and maximum representable quantized values.
-///
-/// e.g.
-///
-/// *   [-128, 127] for signed, num_bits = 8, or
-/// *   [0, 255] for unsigned, num_bits = 8.
-///
-/// If range_given == False, the initial input_min, input_max will be determined
-/// automatically as the minimum and maximum values in the input tensor, otherwise
-/// the specified values of input_min, input_max are used.
-///
-/// Note: If the input_min, input_max are specified, they do not need to equal the
-/// actual minimum and maximum values in the tensor. e.g. in some cases it may be
-/// beneficial to specify these values such that the low probability extremes of the
-/// input distribution are clipped.
-///
-/// This op determines the maximum scale_factor that would map the initial
-/// [input_min, input_max] range to a range that lies within the representable
-/// quantized range.
-///
-/// It determines the scale from one of input_min and input_max, then updates the
-/// other one to maximize the respresentable range.
-///
-/// e.g.
-///
-/// *   if the output is signed, num_bits = 8, [input_min, input_max] = [-10.0,
-///     5.0]: it would use a scale_factor of -128 / -10.0 = 12.8 In this case, it
-///     would update input_max to be 127 / 12.8 = 9.921875
-/// *   if the output is signed, num_bits = 8, [input_min, input_max] = [-10.0,
-///     10.0]: it would use a scale_factor of 127 / 10.0 = 12.7 In this case, it
-///     would update input_min to be 128.0 / 12.7 = -10.07874
-/// *   if the output is unsigned, input_min is forced to be 0, and only the
-///     specified input_max is used.
-///
-/// After determining the scale_factor and updating the input range, it applies the
-/// following to each value in the 'input' tensor.
-///
-/// output = round(clamp(value, input_min, input_max) * scale_factor) / scale_factor.
-///
-/// The above round function rounds the value based on the given round_mode.
-///
-///
-/// - Parameters:
-///   - input: Tensor to quantize and then dequantize.
-///   - input_min: If `range_given == True`, this specifies the minimum input value that needs to
-///     be represented, otherwise it is determined from the min value of the `input`
-///     tensor.
-///   - input_max: If `range_given == True`, this specifies the maximum input value that needs to
-///     be represented, otherwise it is determined from the max value of the `input`
-///     tensor.
-///
-/// - Attrs:
-///   - signed_input: Whether the quantization is signed or unsigned. (actually this parameter should
-///     have been called <b>`signed_output`</b>)
-///   - num_bits: The bitwidth of the quantization.
-///   - range_given: Whether the range is given or should be determined from the `input` tensor.
-///   - round_mode: The 'round_mode' attribute controls which rounding tie-breaking algorithm is
-///     used when rounding float values to their quantized equivalents. The following
-///     rounding modes are currently supported:
-///
-///     *   HALF_TO_EVEN: this is the default round_mode.
-///     *   HALF_UP: round towards positive. In this mode 7.5 rounds up to 8 and -7.5
-///         rounds up to -7.
-///
-@inlinable
-public static func quantizeAndDequantizeV2<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  inputMin: Tensor<T>,
-  inputMax: Tensor<T>,
-  signedInput: Bool = true,
-  numBits: Int64 = 8,
-  rangeGiven: Bool = false,
-  roundMode: RoundMode = .halfToEven
-) -> Tensor<T> {
-  let op = TFE_Op("QuantizeAndDequantizeV2")
-  op.setAttr("signed_input", signedInput)
-  op.setAttr("num_bits", numBits)
-  op.setAttr("range_given", rangeGiven)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("round_mode", roundMode.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputMin)
-  let _ = op.addInput(inputMax)
-  return op.execute(Int(1))
-}
-
-/// Quantizes then dequantizes a tensor.
-///
-/// This is almost identical to QuantizeAndDequantizeV2, except that num_bits is a
-/// tensor, so its value can change during training.
-@inlinable
-public static func quantizeAndDequantizeV3<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  inputMin: Tensor<T>,
-  inputMax: Tensor<T>,
-  numBits: Tensor<Int32>,
-  signedInput: Bool = true,
-  rangeGiven: Bool = true
-) -> Tensor<T> {
-  let op = TFE_Op("QuantizeAndDequantizeV3")
-  op.setAttr("signed_input", signedInput)
-  op.setAttr("range_given", rangeGiven)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputMin)
-  let _ = op.addInput(inputMax)
-  let _ = op.addInput(numBits)
-  return op.execute(Int(1))
-}
-
-/// Convert the quantized 'input' tensor into a lower-precision 'output', using the
-///
-/// actual distribution of the values to maximize the usage of the lower bit depth
-/// and adjusting the output min and max ranges accordingly.
-///
-/// [input_min, input_max] are scalar floats that specify the range for the float
-/// interpretation of the 'input' data. For example, if input_min is -1.0f and
-/// input_max is 1.0f, and we are dealing with quint16 quantized data, then a 0
-/// value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.
-///
-/// This operator tries to squeeze as much precision as possible into an output with
-/// a lower bit depth by calculating the actual min and max values found in the
-/// data. For example, maybe that quint16 input has no values lower than 16,384 and
-/// none higher than 49,152. That means only half the range is actually needed, all
-/// the float interpretations are between -0.5f and 0.5f, so if we want to compress
-/// the data into a quint8 output, we can use that range rather than the theoretical
-/// -1.0f to 1.0f that is suggested by the input min and max.
-///
-/// In practice, this is most useful for taking output from operations like
-/// QuantizedMatMul that can produce higher bit-depth outputs than their inputs and
-/// may have large potential output ranges, but in practice have a distribution of
-/// input values that only uses a small fraction of the possible range. By feeding
-/// that output into this operator, we can reduce it from 32 bits down to 8 with
-/// minimal loss of accuracy.
-///
-/// - Parameters:
-///   - input_min: The float value that the minimum quantized input value represents.
-///   - input_max: The float value that the maximum quantized input value represents.
-///
-/// - Attrs:
-///   - Tinput: The type of the input.
-///   - out_type: The type of the output. Should be a lower bit depth than Tinput.
-///
-/// - Outputs:
-///   - output_min: The float value that the minimum quantized output value represents.
-///   - output_max: The float value that the maximum quantized output value represents.
-@inlinable
-public static func quantizeDownAndShrinkRange<
-    Tinput: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  inputMin: Tensor<Float>,
-  inputMax: Tensor<Float>
-) -> (output: Tensor<OutType>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
-  let op = TFE_Op("QuantizeDownAndShrinkRange")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputMin)
-  let _ = op.addInput(inputMax)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Quantize the 'input' tensor of type float to 'output' tensor of type 'T'.
-///
-/// [min_range, max_range] are scalar floats that specify the range for
-/// the 'input' data. The 'mode' attribute controls exactly which calculations are
-/// used to convert the float values to their quantized equivalents.  The
-/// 'round_mode' attribute controls which rounding tie-breaking algorithm is used
-/// when rounding float values to their quantized equivalents.
-///
-/// In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:
-///
-/// ```
-/// out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
-/// if T == qint8: out[i] -= (range(T) + 1) / 2.0
-/// ```
-///
-/// here `range(T) = numeric_limits<T>::max() - numeric_limits<T>::min()`
-///
-/// *MIN_COMBINED Mode Example*
-///
-/// Assume the input is type float and has a possible range of [0.0, 6.0] and the
-/// output type is quint8 ([0, 255]). The min_range and max_range values should be
-/// specified as 0.0 and 6.0. Quantizing from float to quint8 will multiply each
-/// value of the input by 255/6 and cast to quint8.
-///
-/// If the output type was qint8 ([-128, 127]), the operation will additionally
-/// subtract each value by 128 prior to casting, so that the range of values aligns
-/// with the range of qint8.
-///
-/// If the mode is 'MIN_FIRST', then this approach is used:
-///
-/// ```
-/// num_discrete_values = 1 << (# of bits in T)
-/// range_adjust = num_discrete_values / (num_discrete_values - 1)
-/// range = (range_max - range_min) * range_adjust
-/// range_scale = num_discrete_values / range
-/// quantized = round(input * range_scale) - round(range_min * range_scale) +
-///   numeric_limits<T>::min()
-/// quantized = max(quantized, numeric_limits<T>::min())
-/// quantized = min(quantized, numeric_limits<T>::max())
-/// ```
-///
-/// The biggest difference between this and MIN_COMBINED is that the minimum range
-/// is rounded first, before it's subtracted from the rounded value. With
-/// MIN_COMBINED, a small bias is introduced where repeated iterations of quantizing
-/// and dequantizing will introduce a larger and larger error.
-///
-/// *SCALED mode Example*
-///
-/// `SCALED` mode matches the quantization approach used in
-/// `QuantizeAndDequantize{V2|V3}`.
-///
-/// If the mode is `SCALED`, we do not use the full range of the output type,
-/// choosing to elide the lowest possible value for symmetry (e.g., output range is
-/// -127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to
-/// 0.
-///
-/// We first find the range of values in our tensor. The
-/// range we use is always centered on 0, so we find m such that
-///
-/// ```c++
-///   m = max(abs(input_min), abs(input_max))
-/// ```
-///
-/// Our input tensor range is then `[-m, m]`.
-///
-/// Next, we choose our fixed-point quantization buckets, `[min_fixed, max_fixed]`.
-/// If T is signed, this is
-///
-/// ```
-///   num_bits = sizeof(T) * 8
-///   [min_fixed, max_fixed] =
-///       [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]
-/// ```
-///
-/// Otherwise, if T is unsigned, the fixed-point range is
-///
-/// ```
-///   [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]
-/// ```
-///
-/// From this we compute our scaling factor, s:
-///
-/// ```c++
-///   s = (max_fixed - min_fixed) / (2 * m)
-/// ```
-///
-/// Now we can quantize the elements of our tensor:
-///
-/// ```c++
-/// result = round(input * s)
-/// ```
-///
-/// One thing to watch out for is that the operator may choose to adjust the
-/// requested minimum and maximum values slightly during the quantization process,
-/// so you should always use the output ports as the range for further calculations.
-/// For example, if the requested minimum and maximum values are close to equal,
-/// they will be separated by a small epsilon value to prevent ill-formed quantized
-/// buffers from being created. Otherwise, you can end up with buffers where all the
-/// quantized values map to the same float value, which causes problems for
-/// operations that have to perform further calculations on them.
-///
-/// - Parameters:
-///   - min_range: The minimum scalar value possibly produced for the input.
-///   - max_range: The maximum scalar value possibly produced for the input.
-///
-/// - Outputs:
-///   - output: The quantized data produced from the float input.
-///   - output_min: The actual minimum scalar value used for the output.
-///   - output_max: The actual maximum scalar value used for the output.
-@inlinable
-public static func quantizeV2<T: TensorFlowScalar>(
-  _ input: Tensor<Float>,
-  minRange: Tensor<Float>,
-  maxRange: Tensor<Float>,
-  mode: Mode = .minCombined,
-  roundMode: RoundMode6 = .halfAwayFromZero
-) -> (output: Tensor<T>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
-  let op = TFE_Op("QuantizeV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("mode", mode.cName)
-  op.setAttr("round_mode", roundMode.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(minRange)
-  let _ = op.addInput(maxRange)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Returns x + y element-wise, working on quantized buffers.
-///
-/// - Parameters:
-///   - min_x: The float value that the lowest quantized `x` value represents.
-///   - max_x: The float value that the highest quantized `x` value represents.
-///   - min_y: The float value that the lowest quantized `y` value represents.
-///   - max_y: The float value that the highest quantized `y` value represents.
-///
-/// - Outputs:
-///   - min_z: The float value that the lowest quantized output value represents.
-///   - max_z: The float value that the highest quantized output value represents.
-///
-///     *NOTE*: `QuantizedAdd` supports limited forms of broadcasting. More about
-///     broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func quantizedAdd<
-    T1: TensorFlowScalar,
-    T2: TensorFlowScalar,
-    Toutput: TensorFlowScalar
->(
-  _ x: Tensor<T1>,
-  _ y: Tensor<T2>,
-  minX: Tensor<Float>,
-  maxX: Tensor<Float>,
-  minY: Tensor<Float>,
-  maxY: Tensor<Float>
-) -> (z: Tensor<Toutput>, minZ: Tensor<Float>, maxZ: Tensor<Float>) {
-  let op = TFE_Op("QuantizedAdd")
-  op.setAttr("T1", T1.tensorFlowDataType)
-  op.setAttr("T2", T2.tensorFlowDataType)
-  op.setAttr("Toutput", Toutput.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  let _ = op.addInput(minX)
-  let _ = op.addInput(maxX)
-  let _ = op.addInput(minY)
-  let _ = op.addInput(maxY)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Produces the average pool of the input tensor for quantized types.
-///
-/// - Parameters:
-///   - input: 4-D with shape `[batch, height, width, channels]`.
-///   - min_input: The float value that the lowest quantized input value represents.
-///   - max_input: The float value that the highest quantized input value represents.
-///
-/// - Attrs:
-///   - ksize: The size of the window for each dimension of the input tensor.
-///     The length must be 4 to match the number of dimensions of the input.
-///   - strides: The stride of the sliding window for each dimension of the input
-///     tensor.  The length must be 4 to match the number of dimensions of the input.
-///   - padding: The type of padding algorithm to use.
-///
-/// - Outputs:
-///   - min_output: The float value that the lowest quantized output value represents.
-///   - max_output: The float value that the highest quantized output value represents.
-@inlinable
-public static func quantizedAvgPool<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding
-) -> (output: Tensor<T>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedAvgPool")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Quantized Batch normalization.
-///
-/// This op is deprecated and will be removed in the future. Prefer
-/// `tf.nn.batch_normalization`.
-///
-/// - Parameters:
-///   - t: A 4D input Tensor.
-///   - t_min: The value represented by the lowest quantized input.
-///   - t_max: The value represented by the highest quantized input.
-///   - m: A 1D mean Tensor with size matching the last dimension of t.
-///     This is the first output from tf.nn.moments,
-///     or a saved moving average thereof.
-///   - m_min: The value represented by the lowest quantized mean.
-///   - m_max: The value represented by the highest quantized mean.
-///   - v: A 1D variance Tensor with size matching the last dimension of t.
-///     This is the second output from tf.nn.moments,
-///     or a saved moving average thereof.
-///   - v_min: The value represented by the lowest quantized variance.
-///   - v_max: The value represented by the highest quantized variance.
-///   - beta: A 1D beta Tensor with size matching the last dimension of t.
-///     An offset to be added to the normalized tensor.
-///   - beta_min: The value represented by the lowest quantized offset.
-///   - beta_max: The value represented by the highest quantized offset.
-///   - gamma: A 1D gamma Tensor with size matching the last dimension of t.
-///     If "scale_after_normalization" is true, this tensor will be multiplied
-///     with the normalized tensor.
-///   - gamma_min: The value represented by the lowest quantized gamma.
-///   - gamma_max: The value represented by the highest quantized gamma.
-///
-/// - Attrs:
-///   - variance_epsilon: A small float number to avoid dividing by 0.
-///   - scale_after_normalization: A bool indicating whether the resulted tensor
-///     needs to be multiplied with gamma.
-@inlinable
-public static func quantizedBatchNormWithGlobalNormalization<
-    Tinput: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  t: Tensor<Tinput>,
-  tMin: Tensor<Float>,
-  tMax: Tensor<Float>,
-  m: Tensor<Tinput>,
-  mMin: Tensor<Float>,
-  mMax: Tensor<Float>,
-  v: Tensor<Tinput>,
-  vMin: Tensor<Float>,
-  vMax: Tensor<Float>,
-  beta: Tensor<Tinput>,
-  betaMin: Tensor<Float>,
-  betaMax: Tensor<Float>,
-  gamma: Tensor<Tinput>,
-  gammaMin: Tensor<Float>,
-  gammaMax: Tensor<Float>,
-  varianceEpsilon: Double,
-  scaleAfterNormalization: Bool
-) -> (result: Tensor<OutType>, resultMin: Tensor<Float>, resultMax: Tensor<Float>) {
-  let op = TFE_Op("QuantizedBatchNormWithGlobalNormalization")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("variance_epsilon", varianceEpsilon)
-  op.setAttr("scale_after_normalization", scaleAfterNormalization)
-  let _ = op.addInput(t)
-  let _ = op.addInput(tMin)
-  let _ = op.addInput(tMax)
-  let _ = op.addInput(m)
-  let _ = op.addInput(mMin)
-  let _ = op.addInput(mMax)
-  let _ = op.addInput(v)
-  let _ = op.addInput(vMin)
-  let _ = op.addInput(vMax)
-  let _ = op.addInput(beta)
-  let _ = op.addInput(betaMin)
-  let _ = op.addInput(betaMax)
-  let _ = op.addInput(gamma)
-  let _ = op.addInput(gammaMin)
-  let _ = op.addInput(gammaMax)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Adds Tensor 'bias' to Tensor 'input' for Quantized types.
-///
-/// Broadcasts the values of bias on dimensions 0..N-2 of 'input'.
-///
-/// - Parameters:
-///   - bias: A 1D bias Tensor with size matching the last dimension of 'input'.
-///   - min_input: The float value that the lowest quantized input value represents.
-///   - max_input: The float value that the highest quantized input value represents.
-///   - min_bias: The float value that the lowest quantized bias value represents.
-///   - max_bias: The float value that the highest quantized bias value represents.
-///
-/// - Outputs:
-///   - min_out: The float value that the lowest quantized output value represents.
-///   - max_out: The float value that the highest quantized output value represents.
-@inlinable
-public static func quantizedBiasAdd<
-    T1: TensorFlowScalar,
-    T2: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<T1>,
-  bias: Tensor<T2>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minBias: Tensor<Float>,
-  maxBias: Tensor<Float>
-) -> (output: Tensor<OutType>, minOut: Tensor<Float>, maxOut: Tensor<Float>) {
-  let op = TFE_Op("QuantizedBiasAdd")
-  op.setAttr("T1", T1.tensorFlowDataType)
-  op.setAttr("T2", T2.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(bias)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minBias)
-  let _ = op.addInput(maxBias)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Concatenates quantized tensors along one dimension.
-///
-/// - Parameters:
-///   - concat_dim: 0-D.  The dimension along which to concatenate.  Must be in the
-///     range [0, rank(values)).
-///   - values: The `N` Tensors to concatenate. Their ranks and types must match,
-///     and their sizes must match in all dimensions except `concat_dim`.
-///   - input_mins: The minimum scalar values for each of the input tensors.
-///   - input_maxes: The maximum scalar values for each of the input tensors.
-///
-/// - Outputs:
-///   - output: A `Tensor` with the concatenation of values stacked along the
-///     `concat_dim` dimension.  This tensor's shape matches that of `values` except
-///     in `concat_dim` where it has the sum of the sizes.
-///   - output_min: The float value that the minimum quantized output value represents.
-///   - output_max: The float value that the maximum quantized output value represents.
-@inlinable
-public static func quantizedConcat<T: TensorFlowScalar>(
-  concatDim: Tensor<Int32>,
-  _ values: [Tensor<T>],
-  inputMins: [Tensor<Float>],
-  inputMaxes: [Tensor<Float>]
-) -> (output: Tensor<T>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConcat")
-  op.setAttr("N", values.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(concatDim)
-  let _ = op.addInputList(values)
-  let _ = op.addInputList(inputMins)
-  let _ = op.addInputList(inputMaxes)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Computes a 2D convolution given quantized 4D input and filter tensors.
-///
-/// The inputs are quantized tensors where the lowest value represents the real
-/// number of the associated minimum, and the highest represents the maximum.
-/// This means that you can only interpret the quantized output in the same way, by
-/// taking the returned minimum and maximum values into account.
-///
-/// - Parameters:
-///   - filter: filter's input_depth dimension must match input's depth dimensions.
-///   - min_input: The float value that the lowest quantized input value represents.
-///   - max_input: The float value that the highest quantized input value represents.
-///   - min_filter: The float value that the lowest quantized filter value represents.
-///   - max_filter: The float value that the highest quantized filter value represents.
-///
-/// - Attrs:
-///   - strides: The stride of the sliding window for each dimension of the input
-///     tensor.
-///   - padding: The type of padding algorithm to use.
-///   - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
-///     `input`. If set to k > 1, there will be k-1 skipped cells between each
-///     filter element on that dimension. The dimension order is determined by the
-///     value of `data_format`, see above for details. Dilations in the batch and
-///     depth dimensions must be 1.
-///
-/// - Outputs:
-///   - min_output: The float value that the lowest quantized output value represents.
-///   - max_output: The float value that the highest quantized output value represents.
-@inlinable
-public static func quantizedConv2D<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConv2D")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedConv2DAndRelu<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1],
-  paddingList: [Int32]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConv2DAndRelu")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  op.setAttr("padding_list", paddingList)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedConv2DAndReluAndRequantize<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  minFreezedOutput: Tensor<Float>,
-  maxFreezedOutput: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1],
-  paddingList: [Int32]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConv2DAndReluAndRequantize")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  op.setAttr("padding_list", paddingList)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  let _ = op.addInput(minFreezedOutput)
-  let _ = op.addInput(maxFreezedOutput)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedConv2DAndRequantize<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  minFreezedOutput: Tensor<Float>,
-  maxFreezedOutput: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1],
-  paddingList: [Int32]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConv2DAndRequantize")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  op.setAttr("padding_list", paddingList)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  let _ = op.addInput(minFreezedOutput)
-  let _ = op.addInput(maxFreezedOutput)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Computes QuantizedConv2D per channel.
-///
-/// - Parameters:
-///   - input: The original input tensor.
-///   - filter: The original filter tensor.
-///   - min_input: The minimum value of the input tensor
-///   - max_input: The maximum value of the input tensor.
-///   - min_filter: The minimum value of the filter tensor.
-///   - max_filter: The maximum value of the filter tensor.
-///
-/// - Attrs:
-///   - Tinput: The quantized type of input tensor that needs to be converted. 
-///   - Tfilter: The quantized type of filter tensor that needs to be converted. 
-///   - out_type: The quantized type of output tensor that needs to be converted.
-///   - strides: list of stride values.
-///   - dilations: list of dilation values.
-///
-/// - Outputs:
-///   - output: The output tensor.
-///   - min_output: The minimum value of the final output tensor.
-///   - max_output: The maximum value of the final output tensor.
-@inlinable
-public static func quantizedConv2DPerChannel<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConv2DPerChannel")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedConv2DWithBias<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  bias: Tensor<Float>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1],
-  paddingList: [Int32]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConv2DWithBias")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  op.setAttr("padding_list", paddingList)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(bias)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedConv2DWithBiasAndRelu<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  bias: Tensor<Float>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1],
-  paddingList: [Int32]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConv2DWithBiasAndRelu")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  op.setAttr("padding_list", paddingList)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(bias)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedConv2DWithBiasAndReluAndRequantize<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    Tbias: FloatingPoint & TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  bias: Tensor<Tbias>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  minFreezedOutput: Tensor<Float>,
-  maxFreezedOutput: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1],
-  paddingList: [Int32]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConv2DWithBiasAndReluAndRequantize")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("Tbias", Tbias.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  op.setAttr("padding_list", paddingList)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(bias)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  let _ = op.addInput(minFreezedOutput)
-  let _ = op.addInput(maxFreezedOutput)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedConv2DWithBiasAndRequantize<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    Tbias: FloatingPoint & TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  bias: Tensor<Tbias>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  minFreezedOutput: Tensor<Float>,
-  maxFreezedOutput: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1],
-  paddingList: [Int32]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConv2DWithBiasAndRequantize")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("Tbias", Tbias.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  op.setAttr("padding_list", paddingList)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(bias)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  let _ = op.addInput(minFreezedOutput)
-  let _ = op.addInput(maxFreezedOutput)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedConv2DWithBiasSignedSumAndReluAndRequantize<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    Tbias: FloatingPoint & TensorFlowScalar,
-    Tsummand: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  bias: Tensor<Tbias>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  minFreezedOutput: Tensor<Float>,
-  maxFreezedOutput: Tensor<Float>,
-  summand: Tensor<Tsummand>,
-  minSummand: Tensor<Float>,
-  maxSummand: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1],
-  paddingList: [Int32]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConv2DWithBiasSignedSumAndReluAndRequantize")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("Tbias", Tbias.tensorFlowDataType)
-  op.setAttr("Tsummand", Tsummand.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  op.setAttr("padding_list", paddingList)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(bias)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  let _ = op.addInput(minFreezedOutput)
-  let _ = op.addInput(maxFreezedOutput)
-  let _ = op.addInput(summand)
-  let _ = op.addInput(minSummand)
-  let _ = op.addInput(maxSummand)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedConv2DWithBiasSumAndRelu<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  bias: Tensor<Float>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  summand: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1],
-  paddingList: [Int32]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConv2DWithBiasSumAndRelu")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  op.setAttr("padding_list", paddingList)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(bias)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  let _ = op.addInput(summand)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedConv2DWithBiasSumAndReluAndRequantize<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    Tbias: FloatingPoint & TensorFlowScalar,
-    Tsummand: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  bias: Tensor<Tbias>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  minFreezedOutput: Tensor<Float>,
-  maxFreezedOutput: Tensor<Float>,
-  summand: Tensor<Tsummand>,
-  minSummand: Tensor<Float>,
-  maxSummand: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1],
-  paddingList: [Int32]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedConv2DWithBiasSumAndReluAndRequantize")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("Tbias", Tbias.tensorFlowDataType)
-  op.setAttr("Tsummand", Tsummand.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  op.setAttr("padding_list", paddingList)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(bias)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  let _ = op.addInput(minFreezedOutput)
-  let _ = op.addInput(maxFreezedOutput)
-  let _ = op.addInput(summand)
-  let _ = op.addInput(minSummand)
-  let _ = op.addInput(maxSummand)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedDepthwiseConv2D<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedDepthwiseConv2D")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedDepthwiseConv2DWithBias<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  bias: Tensor<Float>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedDepthwiseConv2DWithBias")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(bias)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedDepthwiseConv2DWithBiasAndRelu<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  bias: Tensor<Float>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedDepthwiseConv2DWithBiasAndRelu")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(bias)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func quantizedDepthwiseConv2DWithBiasAndReluAndRequantize<
-    Tinput: TensorFlowScalar,
-    Tfilter: TensorFlowScalar,
-    Tbias: FloatingPoint & TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  filter: Tensor<Tfilter>,
-  bias: Tensor<Tbias>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  minFilter: Tensor<Float>,
-  maxFilter: Tensor<Float>,
-  minFreezedOutput: Tensor<Float>,
-  maxFreezedOutput: Tensor<Float>,
-  strides: [Int32],
-  padding: Padding,
-  dilations: [Int32] = [1, 1, 1, 1]
-) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("Tfilter", Tfilter.tensorFlowDataType)
-  op.setAttr("Tbias", Tbias.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  op.setAttr("dilations", dilations)
-  let _ = op.addInput(input)
-  let _ = op.addInput(filter)
-  let _ = op.addInput(bias)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  let _ = op.addInput(minFilter)
-  let _ = op.addInput(maxFilter)
-  let _ = op.addInput(minFreezedOutput)
-  let _ = op.addInput(maxFreezedOutput)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Quantized Instance normalization.
-///
-/// - Parameters:
-///   - x: A 4D input Tensor.
-///   - x_min: The value represented by the lowest quantized input.
-///   - x_max: The value represented by the highest quantized input.
-///
-/// - Attrs:
-///   - output_range_given: If True, `given_y_min` and `given_y_min`
-///     and `given_y_max` are used as the output range. Otherwise,
-///     the implementation computes the output range.
-///   - given_y_min: Output in `y_min` if `output_range_given` is True.
-///   - given_y_max: Output in `y_max` if `output_range_given` is True.
-///   - variance_epsilon: A small float number to avoid dividing by 0.
-///   - min_separation: Minimum value of `y_max - y_min`
-///
-/// - Outputs:
-///   - y: A 4D Tensor.
-///   - y_min: The value represented by the lowest quantized output.
-///   - y_max: The value represented by the highest quantized output.
-@inlinable
-public static func quantizedInstanceNorm<T: TensorFlowScalar>(
-  _ x: Tensor<T>,
-  xMin: Tensor<Float>,
-  xMax: Tensor<Float>,
-  outputRangeGiven: Bool = false,
-  givenYMin: Double = 0,
-  givenYMax: Double = 0,
-  varianceEpsilon: Double = 1e-05,
-  minSeparation: Double = 0.001
-) -> (y: Tensor<T>, yMin: Tensor<Float>, yMax: Tensor<Float>) {
-  let op = TFE_Op("QuantizedInstanceNorm")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("output_range_given", outputRangeGiven)
-  op.setAttr("given_y_min", givenYMin)
-  op.setAttr("given_y_max", givenYMax)
-  op.setAttr("variance_epsilon", varianceEpsilon)
-  op.setAttr("min_separation", minSeparation)
-  let _ = op.addInput(x)
-  let _ = op.addInput(xMin)
-  let _ = op.addInput(xMax)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Perform a quantized matrix multiplication of  `a` by the matrix `b`.
-///
-/// The inputs must be two-dimensional matrices and the inner dimension of
-/// `a` (after being transposed if `transpose_a` is non-zero) must match the
-/// outer dimension of `b` (after being transposed if `transposed_b` is
-/// non-zero).
-///
-/// - Parameters:
-///   - a: Must be a two-dimensional tensor.
-///   - b: Must be a two-dimensional tensor.
-///   - min_a: The float value that the lowest quantized `a` value represents.
-///   - max_a: The float value that the highest quantized `a` value represents.
-///   - min_b: The float value that the lowest quantized `b` value represents.
-///   - max_b: The float value that the highest quantized `b` value represents.
-///
-/// - Attrs:
-///   - transpose_a: If true, `a` is transposed before multiplication.
-///   - transpose_b: If true, `b` is transposed before multiplication.
-///   - Tactivation: The type of output produced by activation function
-///     following this operation.
-///
-/// - Outputs:
-///   - min_out: The float value that the lowest quantized output value represents.
-///   - max_out: The float value that the highest quantized output value represents.
-@inlinable
-public static func quantizedMatMul<
-    T1: TensorFlowScalar,
-    T2: TensorFlowScalar,
-    Toutput: TensorFlowScalar
->(
-  _ a: Tensor<T1>,
-  _ b: Tensor<T2>,
-  minA: Tensor<Float>,
-  maxA: Tensor<Float>,
-  minB: Tensor<Float>,
-  maxB: Tensor<Float>,
-  transposeA: Bool = false,
-  transposeB: Bool = false,
-  tactivation: TensorDataType
-) -> (out: Tensor<Toutput>, minOut: Tensor<Float>, maxOut: Tensor<Float>) {
-  let op = TFE_Op("QuantizedMatMul")
-  op.setAttr("T1", T1.tensorFlowDataType)
-  op.setAttr("T2", T2.tensorFlowDataType)
-  op.setAttr("Toutput", Toutput.tensorFlowDataType)
-  op.setAttr("transpose_a", transposeA)
-  op.setAttr("transpose_b", transposeB)
-  op.setAttr("Tactivation", tactivation)
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  let _ = op.addInput(minA)
-  let _ = op.addInput(maxA)
-  let _ = op.addInput(minB)
-  let _ = op.addInput(maxB)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Produces the max pool of the input tensor for quantized types.
-///
-/// - Parameters:
-///   - input: The 4D (batch x rows x cols x depth) Tensor to MaxReduce over.
-///   - min_input: The float value that the lowest quantized input value represents.
-///   - max_input: The float value that the highest quantized input value represents.
-///
-/// - Attrs:
-///   - ksize: The size of the window for each dimension of the input tensor.
-///     The length must be 4 to match the number of dimensions of the input.
-///   - strides: The stride of the sliding window for each dimension of the input
-///     tensor. The length must be 4 to match the number of dimensions of the input.
-///   - padding: The type of padding algorithm to use.
-///
-/// - Outputs:
-///   - min_output: The float value that the lowest quantized output value represents.
-///   - max_output: The float value that the highest quantized output value represents.
-@inlinable
-public static func quantizedMaxPool<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  minInput: Tensor<Float>,
-  maxInput: Tensor<Float>,
-  ksize: [Int32],
-  strides: [Int32],
-  padding: Padding
-) -> (output: Tensor<T>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
-  let op = TFE_Op("QuantizedMaxPool")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("ksize", ksize)
-  op.setAttr("strides", strides)
-  op.setAttr("padding", padding.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(minInput)
-  let _ = op.addInput(maxInput)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Returns x * y element-wise, working on quantized buffers.
-///
-/// - Parameters:
-///   - min_x: The float value that the lowest quantized `x` value represents.
-///   - max_x: The float value that the highest quantized `x` value represents.
-///   - min_y: The float value that the lowest quantized `y` value represents.
-///   - max_y: The float value that the highest quantized `y` value represents.
-///
-/// - Outputs:
-///   - min_z: The float value that the lowest quantized output value represents.
-///   - max_z: The float value that the highest quantized output value represents.
-///
-///     *NOTE*: `QuantizedMul` supports limited forms of broadcasting. More about
-///     broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func quantizedMul<
-    T1: TensorFlowScalar,
-    T2: TensorFlowScalar,
-    Toutput: TensorFlowScalar
->(
-  _ x: Tensor<T1>,
-  _ y: Tensor<T2>,
-  minX: Tensor<Float>,
-  maxX: Tensor<Float>,
-  minY: Tensor<Float>,
-  maxY: Tensor<Float>
-) -> (z: Tensor<Toutput>, minZ: Tensor<Float>, maxZ: Tensor<Float>) {
-  let op = TFE_Op("QuantizedMul")
-  op.setAttr("T1", T1.tensorFlowDataType)
-  op.setAttr("T2", T2.tensorFlowDataType)
-  op.setAttr("Toutput", Toutput.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  let _ = op.addInput(minX)
-  let _ = op.addInput(maxX)
-  let _ = op.addInput(minY)
-  let _ = op.addInput(maxY)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Computes Quantized Rectified Linear: `max(features, 0)`
-///
-/// - Parameters:
-///   - min_features: The float value that the lowest quantized value represents.
-///   - max_features: The float value that the highest quantized value represents.
-///
-/// - Outputs:
-///   - activations: Has the same output shape as "features".
-///   - min_activations: The float value that the lowest quantized value represents.
-///   - max_activations: The float value that the highest quantized value represents.
-@inlinable
-public static func quantizedRelu<
-    Tinput: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  features: Tensor<Tinput>,
-  minFeatures: Tensor<Float>,
-  maxFeatures: Tensor<Float>
-) -> (activations: Tensor<OutType>, minActivations: Tensor<Float>, maxActivations: Tensor<Float>) {
-  let op = TFE_Op("QuantizedRelu")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(features)
-  let _ = op.addInput(minFeatures)
-  let _ = op.addInput(maxFeatures)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Computes Quantized Rectified Linear 6: `min(max(features, 0), 6)`
-///
-/// - Parameters:
-///   - min_features: The float value that the lowest quantized value represents.
-///   - max_features: The float value that the highest quantized value represents.
-///
-/// - Outputs:
-///   - activations: Has the same output shape as "features".
-///   - min_activations: The float value that the lowest quantized value represents.
-///   - max_activations: The float value that the highest quantized value represents.
-@inlinable
-public static func quantizedRelu6<
-    Tinput: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  features: Tensor<Tinput>,
-  minFeatures: Tensor<Float>,
-  maxFeatures: Tensor<Float>
-) -> (activations: Tensor<OutType>, minActivations: Tensor<Float>, maxActivations: Tensor<Float>) {
-  let op = TFE_Op("QuantizedRelu6")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(features)
-  let _ = op.addInput(minFeatures)
-  let _ = op.addInput(maxFeatures)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Computes Quantized Rectified Linear X: `min(max(features, 0), max_value)`
-///
-/// - Parameters:
-///   - min_features: The float value that the lowest quantized value represents.
-///   - max_features: The float value that the highest quantized value represents.
-///
-/// - Outputs:
-///   - activations: Has the same output shape as "features".
-///   - min_activations: The float value that the lowest quantized value represents.
-///   - max_activations: The float value that the highest quantized value represents.
-@inlinable
-public static func quantizedReluX<
-    Tinput: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  features: Tensor<Tinput>,
-  maxValue: Tensor<Float>,
-  minFeatures: Tensor<Float>,
-  maxFeatures: Tensor<Float>
-) -> (activations: Tensor<OutType>, minActivations: Tensor<Float>, maxActivations: Tensor<Float>) {
-  let op = TFE_Op("QuantizedReluX")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(features)
-  let _ = op.addInput(maxValue)
-  let _ = op.addInput(minFeatures)
-  let _ = op.addInput(maxFeatures)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Reshapes a quantized tensor as per the Reshape op.
-///
-/// ```
-///
-/// - Parameters:
-///   - shape: Defines the shape of the output tensor.
-///   - input_min: The minimum value of the input.
-///   - input_max: The maximum value of the input.
-///
-/// - Outputs:
-///   - output_min: This value is copied from input_min.
-///   - output_max: This value is copied from input_max.
-@inlinable
-public static func quantizedReshape<
-    T: TensorFlowScalar,
-    Tshape: BinaryInteger & TensorFlowScalar
->(
-  _ tensor: Tensor<T>,
-  shape: Tensor<Tshape>,
-  inputMin: Tensor<Float>,
-  inputMax: Tensor<Float>
-) -> (output: Tensor<T>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
-  let op = TFE_Op("QuantizedReshape")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tshape", Tshape.tensorFlowDataType)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(inputMin)
-  let _ = op.addInput(inputMax)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Resize quantized `images` to `size` using quantized bilinear interpolation.
-///
-/// Input images and output images must be quantized types.
-///
-/// - Parameters:
-///   - images: 4-D with shape `[batch, height, width, channels]`.
-///   - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
-///     new size for the images.
-///
-/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
-///   aligned, preserving the values at the corner pixels. Defaults to false.
-///
-/// - Output resized_images: 4-D with shape
-///   `[batch, new_height, new_width, channels]`.
-@inlinable
-public static func quantizedResizeBilinear<T: FloatingPoint & TensorFlowScalar>(
-  images: Tensor<T>,
-  size: Tensor<Int32>,
-  min: Tensor<Float>,
-  max: Tensor<Float>,
-  alignCorners: Bool = false,
-  halfPixelCenters: Bool = false
-) -> (resizedImages: Tensor<T>, outMin: Tensor<Float>, outMax: Tensor<Float>) {
-  let op = TFE_Op("QuantizedResizeBilinear")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("align_corners", alignCorners)
-  op.setAttr("half_pixel_centers", halfPixelCenters)
-  let _ = op.addInput(images)
-  let _ = op.addInput(size)
-  let _ = op.addInput(min)
-  let _ = op.addInput(max)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Closes the given queue.
-///
-/// This operation signals that no more elements will be enqueued in the
-/// given queue. Subsequent Enqueue(Many) operations will fail.
-/// Subsequent Dequeue(Many) operations will continue to succeed if
-/// sufficient elements remain in the queue. Subsequent Dequeue(Many)
-/// operations that would block will fail immediately.
-///
-/// - Parameter handle: The handle to a queue.
-///
-/// - Attr cancel_pending_enqueues: If true, all pending enqueue requests that are
-///   blocked on the given queue will be canceled.
-@inlinable
-public static func queueCloseV2(
-  handle: ResourceHandle,
-  cancelPendingEnqueues: Bool = false
-) {
-  let op = TFE_Op("QueueCloseV2")
-  op.setAttr("cancel_pending_enqueues", cancelPendingEnqueues)
-  let _ = op.addInput(handle)
-  op.execute()
-}
-
-/// Dequeues `n` tuples of one or more tensors from the given queue.
-///
-/// If the queue is closed and there are fewer than `n` elements, then an
-/// OutOfRange error is returned.
-///
-/// This operation concatenates queue-element component tensors along the
-/// 0th dimension to make a single component tensor.  All of the components
-/// in the dequeued tuple will have size `n` in the 0th dimension.
-///
-/// This operation has `k` outputs, where `k` is the number of components in
-/// the tuples stored in the given queue, and output `i` is the ith
-/// component of the dequeued tuple.
-///
-/// N.B. If the queue is empty, this operation will block until `n` elements
-/// have been dequeued (or 'timeout_ms' elapses, if specified).
-///
-/// - Parameters:
-///   - handle: The handle to a queue.
-///   - n: The number of tuples to dequeue.
-///
-/// - Attrs:
-///   - component_types: The type of each component in a tuple.
-///   - timeout_ms: If the queue has fewer than n elements, this operation
-///     will block for up to timeout_ms milliseconds.
-///     Note: This option is not supported yet.
-///
-/// - Output components: One or more tensors that were dequeued as a tuple.
-@inlinable
-public static func queueDequeueManyV2<ComponentTypes: TensorGroup>(
-  handle: ResourceHandle,
-  n: Tensor<Int32>,
-  timeoutMs: Int64 = -1
-) -> ComponentTypes {
-  let op = TFE_Op("QueueDequeueManyV2")
-  op.setAttr("component_types", ComponentTypes._typeList)
-  op.setAttr("timeout_ms", timeoutMs)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(n)
-  return op.execute(Int(ComponentTypes._typeList.count))
-}
-
-/// Dequeues `n` tuples of one or more tensors from the given queue.
-///
-/// This operation is not supported by all queues.  If a queue does not support
-/// DequeueUpTo, then an Unimplemented error is returned.
-///
-/// If the queue is closed and there are more than 0 but less than `n`
-/// elements remaining, then instead of returning an OutOfRange error like
-/// QueueDequeueMany, less than `n` elements are returned immediately.  If
-/// the queue is closed and there are 0 elements left in the queue, then
-/// an OutOfRange error is returned just like in QueueDequeueMany.
-/// Otherwise the behavior is identical to QueueDequeueMany:
-///
-/// This operation concatenates queue-element component tensors along the
-/// 0th dimension to make a single component tensor.  All of the components
-/// in the dequeued tuple will have size n in the 0th dimension.
-///
-/// This operation has `k` outputs, where `k` is the number of components in
-/// the tuples stored in the given queue, and output `i` is the ith
-/// component of the dequeued tuple.
-///
-/// - Parameters:
-///   - handle: The handle to a queue.
-///   - n: The number of tuples to dequeue.
-///
-/// - Attrs:
-///   - component_types: The type of each component in a tuple.
-///   - timeout_ms: If the queue has fewer than n elements, this operation
-///     will block for up to timeout_ms milliseconds.
-///     Note: This option is not supported yet.
-///
-/// - Output components: One or more tensors that were dequeued as a tuple.
-@inlinable
-public static func queueDequeueUpToV2<ComponentTypes: TensorGroup>(
-  handle: ResourceHandle,
-  n: Tensor<Int32>,
-  timeoutMs: Int64 = -1
-) -> ComponentTypes {
-  let op = TFE_Op("QueueDequeueUpToV2")
-  op.setAttr("component_types", ComponentTypes._typeList)
-  op.setAttr("timeout_ms", timeoutMs)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(n)
-  return op.execute(Int(ComponentTypes._typeList.count))
-}
-
-/// Dequeues a tuple of one or more tensors from the given queue.
-///
-/// This operation has k outputs, where k is the number of components
-/// in the tuples stored in the given queue, and output i is the ith
-/// component of the dequeued tuple.
-///
-/// N.B. If the queue is empty, this operation will block until an element
-/// has been dequeued (or 'timeout_ms' elapses, if specified).
-///
-/// - Parameter handle: The handle to a queue.
-///
-/// - Attrs:
-///   - component_types: The type of each component in a tuple.
-///   - timeout_ms: If the queue is empty, this operation will block for up to
-///     timeout_ms milliseconds.
-///     Note: This option is not supported yet.
-///
-/// - Output components: One or more tensors that were dequeued as a tuple.
-@inlinable
-public static func queueDequeueV2<ComponentTypes: TensorGroup>(
-  handle: ResourceHandle,
-  timeoutMs: Int64 = -1
-) -> ComponentTypes {
-  let op = TFE_Op("QueueDequeueV2")
-  op.setAttr("component_types", ComponentTypes._typeList)
-  op.setAttr("timeout_ms", timeoutMs)
-  let _ = op.addInput(handle)
-  return op.execute(Int(ComponentTypes._typeList.count))
-}
-
-/// Enqueues zero or more tuples of one or more tensors in the given queue.
-///
-/// This operation slices each component tensor along the 0th dimension to
-/// make multiple queue elements. All of the tuple components must have the
-/// same size in the 0th dimension.
-///
-/// The components input has k elements, which correspond to the components of
-/// tuples stored in the given queue.
-///
-/// N.B. If the queue is full, this operation will block until the given
-/// elements have been enqueued (or 'timeout_ms' elapses, if specified).
-///
-/// - Parameters:
-///   - handle: The handle to a queue.
-///   - components: One or more tensors from which the enqueued tensors should
-///     be taken.
-///
-/// - Attr timeout_ms: If the queue is too full, this operation will block for up
-///   to timeout_ms milliseconds.
-///   Note: This option is not supported yet.
-@inlinable
-public static func queueEnqueueManyV2<Tcomponents: TensorArrayProtocol>(
-  handle: ResourceHandle,
-  components: Tcomponents,
-  timeoutMs: Int64 = -1
-) {
-  let op = TFE_Op("QueueEnqueueManyV2")
-  op.setAttr("Tcomponents", components._typeList)
-  op.setAttr("timeout_ms", timeoutMs)
-  let _ = op.addInput(handle)
-  let _ = op.addInputList(components)
-  op.execute()
-}
-
-/// Enqueues a tuple of one or more tensors in the given queue.
-///
-/// The components input has k elements, which correspond to the components of
-/// tuples stored in the given queue.
-///
-/// N.B. If the queue is full, this operation will block until the given
-/// element has been enqueued (or 'timeout_ms' elapses, if specified).
-///
-/// - Parameters:
-///   - handle: The handle to a queue.
-///   - components: One or more tensors from which the enqueued tensors should be taken.
-///
-/// - Attr timeout_ms: If the queue is full, this operation will block for up to
-///   timeout_ms milliseconds.
-///   Note: This option is not supported yet.
-@inlinable
-public static func queueEnqueueV2<Tcomponents: TensorArrayProtocol>(
-  handle: ResourceHandle,
-  components: Tcomponents,
-  timeoutMs: Int64 = -1
-) {
-  let op = TFE_Op("QueueEnqueueV2")
-  op.setAttr("Tcomponents", components._typeList)
-  op.setAttr("timeout_ms", timeoutMs)
-  let _ = op.addInput(handle)
-  let _ = op.addInputList(components)
-  op.execute()
-}
-
-/// Returns true if queue is closed.
-///
-/// This operation returns true if the queue is closed and false if the queue
-/// is open.
-///
-/// - Parameter handle: The handle to a queue.
-@inlinable
-public static func queueIsClosedV2(
-  handle: ResourceHandle
-) -> Tensor<Bool> {
-  let op = TFE_Op("QueueIsClosedV2")
-  let _ = op.addInput(handle)
-  return op.execute(Int(1))
-}
-
-/// Computes the number of elements in the given queue.
-///
-/// - Parameter handle: The handle to a queue.
-///
-/// - Output size: The number of elements in the given queue.
-@inlinable
-public static func queueSizeV2(
-  handle: ResourceHandle
-) -> Tensor<Int32> {
-  let op = TFE_Op("QueueSizeV2")
-  let _ = op.addInput(handle)
-  return op.execute(Int(1))
-}
-
-/// Converts one or more images from RGB to HSV.
-///
-/// Outputs a tensor of the same shape as the `images` tensor, containing the HSV
-/// value of the pixels. The output is only well defined if the value in `images`
-/// are in `[0,1]`.
-///
-/// `output[..., 0]` contains hue, `output[..., 1]` contains saturation, and
-/// `output[..., 2]` contains value. All HSV values are in `[0,1]`. A hue of 0
-/// corresponds to pure red, hue 1/3 is pure green, and 2/3 is pure blue.
-///
-/// - Parameter images: 1-D or higher rank. RGB data to convert. Last dimension must be size 3.
-///
-/// - Output output: `images` converted to HSV.
-@inlinable
-public static func rGBToHSV<T: FloatingPoint & TensorFlowScalar>(
-  images: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("RGBToHSV")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(images)
-  return op.execute(Int(1))
-}
-
-/// Gather ragged slices from `params` axis `0` according to `indices`.
-///
-/// Outputs a `RaggedTensor` output composed from `output_dense_values` and
-/// `output_nested_splits`, such that:
-///
-/// ```python
-/// output.shape = indices.shape + params.shape[1:]
-/// output.ragged_rank = indices.shape.ndims + params.ragged_rank
-/// output[i...j, d0...dn] = params[indices[i...j], d0...dn]
-/// ```
-///
-/// where
-///
-/// * `params =
-///    ragged.from_nested_row_splits(params_dense_values, params_nested_splits)`
-///    provides the values that should be gathered.
-/// * `indices` ia a dense tensor with dtype `int32` or `int64`, indicating which
-///    values should be gathered.
-/// * `output =
-///    ragged.from_nested_row_splits(output_dense_values, output_nested_splits)`
-///    is the output tensor.
-///
-/// (Note: This c++ op is used to implement the higher-level python
-/// `tf.ragged.gather` op, which also supports ragged indices.)
-///
-///
-/// - Parameters:
-///   - params_nested_splits: The `nested_row_splits` tensors that define the row-partitioning for the
-///     `params` RaggedTensor input.
-///   - params_dense_values: The `flat_values` for the `params` RaggedTensor. There was a terminology change
-///     at the python level from dense_values to flat_values, so dense_values is the
-///     deprecated name.
-///   - indices: Indices in the outermost dimension of `params` of the values that should be
-///     gathered.
-///
-/// - Attrs:
-///   - PARAMS_RAGGED_RANK: The ragged rank of the `params` RaggedTensor. `params_nested_splits` should
-///     contain this number of `row_splits` tensors. This value should equal
-///     `params.ragged_rank`.
-///   - OUTPUT_RAGGED_RANK: The ragged rank of the output RaggedTensor. `output_nested_splits` will contain
-///     this number of `row_splits` tensors. This value should equal
-///     `indices.shape.ndims + params.ragged_rank - 1`.
-///
-/// - Outputs:
-///   - output_nested_splits: The `nested_row_splits` tensors that define the row-partitioning for the
-///     returned RaggedTensor.
-///   - output_dense_values: The `flat_values` for the returned RaggedTensor.
-@inlinable
-public static func raggedGather<
-    Tvalues: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  paramsNestedSplits: [Tensor<Int64>],
-  paramsDenseValues: Tensor<Tvalues>,
-  indices: Tensor<Tindices>,
-  oUTPUTRAGGEDRANK: Int64
-) -> (outputNestedSplits: [Tensor<Int64>], outputDenseValues: Tensor<Tvalues>) {
-  let op = TFE_Op("RaggedGather")
-  op.setAttr("Tvalues", Tvalues.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("PARAMS_RAGGED_RANK", paramsNestedSplits.count)
-  op.setAttr("OUTPUT_RAGGED_RANK", oUTPUTRAGGEDRANK)
-  let _ = op.addInputList(paramsNestedSplits)
-  let _ = op.addInput(paramsDenseValues)
-  let _ = op.addInput(indices)
-  return op.execute(Int(oUTPUTRAGGEDRANK), Int(1))
-}
-
-/// Returns a `RaggedTensor` containing the specified sequences of numbers.
-///
-///
-/// Returns a `RaggedTensor` `result` composed from `rt_dense_values` and
-/// `rt_nested_splits`, such that
-/// `result[i] = range(starts[i], limits[i], deltas[i])`.
-///
-/// ```python
-/// >>> (rt_nested_splits, rt_dense_values) = gen_ragged_ops.ragged_range(
-/// ...     starts=[2, 5, 8], limits=[3, 5, 12], deltas=1)
-/// >>> result = ragged.from_nested_row_splits(rt_dense_values, rt_nested_splits)
-/// >>> print result.eval().tolist()
-/// [[2],               # result[0] = range(2, 3)
-///  [],                # result[1] = range(5, 5)
-///  [8, 9, 10, 11]]    # result[2] = range(8, 12)
-/// ```
-///
-/// The input tensors `starts`, `limits`, and `deltas` may be scalars or vectors.
-/// The vector inputs must all have the same size.  Scalar inputs are broadcast
-/// to match the size of the vector inputs.
-///
-/// - Parameters:
-///   - starts: The starts of each range.
-///   - limits: The limits of each range.
-///   - deltas: The deltas of each range.
-///
-/// - Outputs:
-///   - rt_nested_splits: The `row_splits` for the returned `RaggedTensor`.
-///   - rt_dense_values: The `flat_values` for the returned `RaggedTensor`.
-@inlinable
-public static func raggedRange<T: Numeric & TensorFlowScalar>(
-  starts: Tensor<T>,
-  limits: Tensor<T>,
-  deltas: Tensor<T>
-) -> (rtNestedSplits: Tensor<Int64>, rtDenseValues: Tensor<T>) {
-  let op = TFE_Op("RaggedRange")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(starts)
-  let _ = op.addInput(limits)
-  let _ = op.addInput(deltas)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Converts a `RaggedTensor` into a `SparseTensor` with the same values.
-///
-/// input=ragged.from_nested_row_splits(rt_dense_values, rt_nested_splits)
-/// output=SparseTensor(indices=sparse_indices, values=sparse_values,
-///                     dense_shape=sparse_dense_shape)
-///
-/// - Parameters:
-///   - rt_nested_splits: The `row_splits` for the `RaggedTensor`.
-///   - rt_dense_values: The `flat_values` for the `RaggedTensor`.
-///
-/// - Attr RAGGED_RANK: The ragged rank of the input RaggedTensor.  `rt_nested_splits` should contain
-///   this number of ragged-splits tensors.  This value should equal
-///   `input.ragged_rank`.
-///
-/// - Outputs:
-///   - sparse_indices: The indices for the `SparseTensor`.
-///   - sparse_values: The values of the `SparseTensor`.
-///   - sparse_dense_shape: `sparse_dense_shape` is a tight bounding box of the input `RaggedTensor`.
-@inlinable
-public static func raggedTensorToSparse<T: TensorFlowScalar>(
-  rtNestedSplits: [Tensor<Int64>],
-  rtDenseValues: Tensor<T>
-) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<T>, sparseDenseShape: Tensor<Int64>) {
-  let op = TFE_Op("RaggedTensorToSparse")
-  op.setAttr("RAGGED_RANK", rtNestedSplits.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInputList(rtNestedSplits)
-  let _ = op.addInput(rtDenseValues)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Randomly crop `image`.
-///
-/// `size` is a 1-D int64 tensor with 2 elements representing the crop height and
-/// width.  The values must be non negative.
-///
-/// This Op picks a random location in `image` and crops a `height` by `width`
-/// rectangle from that location.  The random location is picked so the cropped
-/// area will fit inside the original image.
-///
-/// - Parameters:
-///   - image: 3-D of shape `[height, width, channels]`.
-///   - size: 1-D of length 2 containing: `crop_height`, `crop_width`..
-///
-/// - Attrs:
-///   - seed: If either seed or seed2 are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: An second seed to avoid seed collision.
-///
-/// - Output output: 3-D of shape `[crop_height, crop_width, channels].`
-@inlinable
-public static func randomCrop<T: Numeric & TensorFlowScalar>(
-  image: Tensor<T>,
-  size: Tensor<Int64>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<T> {
-  let op = TFE_Op("RandomCrop")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(image)
-  let _ = op.addInput(size)
-  return op.execute(Int(1))
-}
-
-/// Outputs random values from the Gamma distribution(s) described by alpha.
-///
-/// This op uses the algorithm by Marsaglia et al. to acquire samples via
-/// transformation-rejection from pairs of uniform and normal random variables.
-/// See http://dl.acm.org/citation.cfm?id=358414
-///
-/// - Parameters:
-///   - shape: 1-D integer tensor. Shape of independent samples to draw from each
-///     distribution described by the shape parameters given in alpha.
-///   - alpha: A tensor in which each scalar is a "shape" parameter describing the
-///     associated gamma distribution.
-///
-/// - Attrs:
-///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: A second seed to avoid seed collision.
-///
-/// - Output output: A tensor with shape `shape + shape(alpha)`. Each slice
-///   `[:, ..., :, i0, i1, ...iN]` contains the samples drawn for
-///   `alpha[i0, i1, ...iN]`. The dtype of the output matches the dtype of alpha.
-@inlinable
-public static func randomGamma<
-    S: BinaryInteger & TensorFlowScalar,
-    T: FloatingPoint & TensorFlowScalar
->(
-  shape: Tensor<S>,
-  alpha: Tensor<T>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<T> {
-  let op = TFE_Op("RandomGamma")
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("S", S.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(alpha)
-  return op.execute(Int(1))
-}
-
-/// Computes the derivative of a Gamma random sample w.r.t. `alpha`.
-@inlinable
-public static func randomGammaGrad<T: FloatingPoint & TensorFlowScalar>(
-  alpha: Tensor<T>,
-  sample: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("RandomGammaGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(alpha)
-  let _ = op.addInput(sample)
-  return op.execute(Int(1))
-}
-
-/// Use RandomPoissonV2 instead.
-@inlinable
-public static func randomPoisson<
-    S: BinaryInteger & TensorFlowScalar,
-    Dtype: FloatingPoint & TensorFlowScalar
->(
-  shape: Tensor<S>,
-  rate: Tensor<Dtype>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<Dtype> {
-  let op = TFE_Op("RandomPoisson")
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("S", S.tensorFlowDataType)
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(rate)
-  return op.execute(Int(1))
-}
-
-/// Outputs random values from the Poisson distribution(s) described by rate.
-///
-/// This op uses two algorithms, depending on rate. If rate >= 10, then
-/// the algorithm by Hormann is used to acquire samples via
-/// transformation-rejection.
-/// See http://www.sciencedirect.com/science/article/pii/0167668793909974.
-///
-/// Otherwise, Knuth's algorithm is used to acquire samples via multiplying uniform
-/// random variables.
-/// See Donald E. Knuth (1969). Seminumerical Algorithms. The Art of Computer
-/// Programming, Volume 2. Addison Wesley
-///
-/// - Parameters:
-///   - shape: 1-D integer tensor. Shape of independent samples to draw from each
-///     distribution described by the shape parameters given in rate.
-///   - rate: A tensor in which each scalar is a "rate" parameter describing the
-///     associated poisson distribution.
-///
-/// - Attrs:
-///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: A second seed to avoid seed collision.
-///
-/// - Output output: A tensor with shape `shape + shape(rate)`. Each slice
-///   `[:, ..., :, i0, i1, ...iN]` contains the samples drawn for
-///   `rate[i0, i1, ...iN]`.
-@inlinable
-public static func randomPoissonV2<
-    S: BinaryInteger & TensorFlowScalar,
-    R: Numeric & TensorFlowScalar,
-    Dtype: Numeric & TensorFlowScalar
->(
-  shape: Tensor<S>,
-  rate: Tensor<R>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<Dtype> {
-  let op = TFE_Op("RandomPoissonV2")
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("S", S.tensorFlowDataType)
-  op.setAttr("R", R.tensorFlowDataType)
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(rate)
-  return op.execute(Int(1))
-}
-
-/// Randomly shuffles a tensor along its first dimension.
-///
-///   The tensor is shuffled along dimension 0, such that each `value[j]` is mapped
-///   to one and only one `output[i]`. For example, a mapping that might occur for a
-///   3x2 tensor is:
-///
-/// ```
-/// [[1, 2],       [[5, 6],
-///  [3, 4],  ==>   [1, 2],
-///  [5, 6]]        [3, 4]]
-/// ```
-///
-/// - Parameter value: The tensor to be shuffled.
-///
-/// - Attrs:
-///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: A second seed to avoid seed collision.
-///
-/// - Output output: A tensor of same shape and type as `value`, shuffled along its first
-///   dimension.
-@inlinable
-public static func randomShuffle<T: TensorFlowScalar>(
-  value: Tensor<T>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<T> {
-  let op = TFE_Op("RandomShuffle")
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(value)
-  return op.execute(Int(1))
-}
-
-/// A queue that randomizes the order of elements.
-///
-/// - Attrs:
-///   - component_types: The type of each component in a value.
-///   - shapes: The shape of each component in a value. The length of this attr must
-///     be either 0 or the same as the length of component_types. If the length of
-///     this attr is 0, the shapes of queue elements are not constrained, and
-///     only one element may be dequeued at a time.
-///   - capacity: The upper bound on the number of elements in this queue.
-///     Negative numbers mean no limit.
-///   - min_after_dequeue: Dequeue will block unless there would be this
-///     many elements after the dequeue or the queue is closed. This
-///     ensures a minimum level of mixing of elements.
-///   - seed: If either seed or seed2 is set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, a random seed is used.
-///   - seed2: A second seed to avoid seed collision.
-///   - container: If non-empty, this queue is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this queue will be shared under the given name
-///     across multiple sessions.
-///
-/// - Output handle: The handle to the queue.
-@inlinable
-public static func randomShuffleQueueV2(
-  componentTypes: [TensorDataType],
-  shapes: [TensorShape?],
-  capacity: Int64 = -1,
-  minAfterDequeue: Int64 = 0,
-  seed: Int64 = 0,
-  seed2: Int64 = 0,
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("RandomShuffleQueueV2")
-  op.setAttr("component_types", componentTypes)
-  op.setAttr("shapes", shapes)
-  op.setAttr("capacity", capacity)
-  op.setAttr("min_after_dequeue", minAfterDequeue)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Outputs random values from a normal distribution.
-///
-/// The generated values will have mean 0 and standard deviation 1.
-///
-/// - Parameter shape: The shape of the output tensor.
-///
-/// - Attrs:
-///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: A second seed to avoid seed collision.
-///   - dtype: The type of the output.
-///
-/// - Output output: A tensor of the specified shape filled with random normal values.
-@inlinable
-public static func randomStandardNormal<
-    Dtype: FloatingPoint & TensorFlowScalar,
-    T: BinaryInteger & TensorFlowScalar
->(
-  shape: Tensor<T>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<Dtype> {
-  let op = TFE_Op("RandomStandardNormal")
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Outputs random values from a uniform distribution.
-///
-/// The generated values follow a uniform distribution in the range `[0, 1)`. The
-/// lower bound 0 is included in the range, while the upper bound 1 is excluded.
-///
-/// - Parameter shape: The shape of the output tensor.
-///
-/// - Attrs:
-///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: A second seed to avoid seed collision.
-///   - dtype: The type of the output.
-///
-/// - Output output: A tensor of the specified shape filled with uniform random values.
-@inlinable
-public static func randomUniform<
-    Dtype: FloatingPoint & TensorFlowScalar,
-    T: BinaryInteger & TensorFlowScalar
->(
-  shape: Tensor<T>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<Dtype> {
-  let op = TFE_Op("RandomUniform")
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Outputs random integers from a uniform distribution.
-///
-/// The generated values are uniform integers in the range `[minval, maxval)`.
-/// The lower bound `minval` is included in the range, while the upper bound
-/// `maxval` is excluded.
-///
-/// The random integers are slightly biased unless `maxval - minval` is an exact
-/// power of two.  The bias is small for values of `maxval - minval` significantly
-/// smaller than the range of the output (either `2^32` or `2^64`).
-///
-/// - Parameters:
-///   - shape: The shape of the output tensor.
-///   - minval: 0-D.  Inclusive lower bound on the generated integers.
-///   - maxval: 0-D.  Exclusive upper bound on the generated integers.
-///
-/// - Attrs:
-///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: A second seed to avoid seed collision.
-///
-/// - Output output: A tensor of the specified shape filled with uniform random integers.
-@inlinable
-public static func randomUniformInt<
-    Tout: BinaryInteger & TensorFlowScalar,
-    T: BinaryInteger & TensorFlowScalar
->(
-  shape: Tensor<T>,
-  minval: Tensor<Tout>,
-  maxval: Tensor<Tout>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<Tout> {
-  let op = TFE_Op("RandomUniformInt")
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("Tout", Tout.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(minval)
-  let _ = op.addInput(maxval)
-  return op.execute(Int(1))
-}
-
-/// Creates a sequence of numbers.
-///
-/// This operation creates a sequence of numbers that begins at `start` and
-/// extends by increments of `delta` up to but not including `limit`.
-///
-/// For example:
-///
-/// ```
-/// # 'start' is 3
-/// # 'limit' is 18
-/// # 'delta' is 3
-/// tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]
-/// ```
-///
-/// - Parameters:
-///   - start: 0-D (scalar). First entry in the sequence.
-///   - limit: 0-D (scalar). Upper limit of sequence, exclusive.
-///   - delta: 0-D (scalar). Optional. Default is 1. Number that increments `start`.
-///
-/// - Output output: 1-D.
-@inlinable
-public static func range<Tidx: Numeric & TensorFlowScalar>(
-  start: Tensor<Tidx>,
-  limit: Tensor<Tidx>,
-  delta: Tensor<Tidx>
-) -> Tensor<Tidx> {
-  let op = TFE_Op("Range")
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(start)
-  let _ = op.addInput(limit)
-  let _ = op.addInput(delta)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset with a range of values. Corresponds to python's xrange.
-///
-/// - Parameters:
-///   - start: corresponds to start in python's xrange().
-///   - stop: corresponds to stop in python's xrange().
-///   - step: corresponds to step in python's xrange().
-@inlinable
-public static func rangeDataset(
-  start: Tensor<Int64>,
-  stop: Tensor<Int64>,
-  step: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("RangeDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(start)
-  let _ = op.addInput(stop)
-  let _ = op.addInput(step)
-  return op.execute(Int(1))
-}
-
-/// Returns the rank of a tensor.
-///
-/// This operation returns an integer representing the rank of `input`.
-///
-/// For example:
-///
-/// ```
-/// # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
-/// # shape of tensor 't' is [2, 2, 3]
-/// rank(t) ==> 3
-/// ```
-///
-/// **Note**: The rank of a tensor is not the same as the rank of a matrix. The rank
-/// of a tensor is the number of indices required to uniquely select each element
-/// of the tensor. Rank is also known as "order", "degree", or "ndims."
-@inlinable
-public static func rank<T: TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<Int32> {
-  let op = TFE_Op("Rank")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Reads and outputs the entire contents of the input filename.
-@inlinable
-public static func readFile(
-  filename: StringTensor
-) -> StringTensor {
-  let op = TFE_Op("ReadFile")
-  let _ = op.addInput(filename)
-  return op.execute(Int(1))
-}
-
-/// Reads the value of a variable.
-///
-/// The tensor returned by this operation is immutable.
-///
-/// The value returned by this operation is guaranteed to be influenced by all the
-/// writes on which this operation depends directly or indirectly, and to not be
-/// influenced by any of the writes which depend directly or indirectly on this
-/// operation.
-///
-/// - Parameter resource: handle to the resource in which to store the variable.
-///
-/// - Attr dtype: the dtype of the value.
-@inlinable
-public static func readVariableOp<Dtype: TensorFlowScalar>(
-  resource: ResourceHandle
-) -> Tensor<Dtype> {
-  let op = TFE_Op("ReadVariableOp")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  return op.execute(Int(1))
-}
-
-/// Returns the number of records this Reader has produced.
-///
-/// This is the same as the number of ReaderRead executions that have
-/// succeeded.
-///
-/// - Parameter reader_handle: Handle to a Reader.
-@inlinable
-public static func readerNumRecordsProducedV2(
-  readerHandle: ResourceHandle
-) -> Tensor<Int64> {
-  let op = TFE_Op("ReaderNumRecordsProducedV2")
-  let _ = op.addInput(readerHandle)
-  return op.execute(Int(1))
-}
-
-/// Returns the number of work units this Reader has finished processing.
-///
-/// - Parameter reader_handle: Handle to a Reader.
-@inlinable
-public static func readerNumWorkUnitsCompletedV2(
-  readerHandle: ResourceHandle
-) -> Tensor<Int64> {
-  let op = TFE_Op("ReaderNumWorkUnitsCompletedV2")
-  let _ = op.addInput(readerHandle)
-  return op.execute(Int(1))
-}
-
-/// Returns up to `num_records` (key, value) pairs produced by a Reader.
-///
-/// Will dequeue from the input queue if necessary (e.g. when the
-/// Reader needs to start reading from a new file since it has finished
-/// with the previous file).
-/// It may return less than `num_records` even before the last batch.
-///
-/// - Parameters:
-///   - reader_handle: Handle to a `Reader`.
-///   - queue_handle: Handle to a `Queue`, with string work items.
-///   - num_records: number of records to read from `Reader`.
-///
-/// - Outputs:
-///   - keys: A 1-D tensor.
-///   - values: A 1-D tensor.
-@inlinable
-public static func readerReadUpToV2(
-  readerHandle: ResourceHandle,
-  queueHandle: ResourceHandle,
-  numRecords: Tensor<Int64>
-) -> (keys: StringTensor, values: StringTensor) {
-  let op = TFE_Op("ReaderReadUpToV2")
-  let _ = op.addInput(readerHandle)
-  let _ = op.addInput(queueHandle)
-  let _ = op.addInput(numRecords)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Returns the next record (key, value pair) produced by a Reader.
-///
-/// Will dequeue from the input queue if necessary (e.g. when the
-/// Reader needs to start reading from a new file since it has finished
-/// with the previous file).
-///
-/// - Parameters:
-///   - reader_handle: Handle to a Reader.
-///   - queue_handle: Handle to a Queue, with string work items.
-///
-/// - Outputs:
-///   - key: A scalar.
-///   - value: A scalar.
-@inlinable
-public static func readerReadV2(
-  readerHandle: ResourceHandle,
-  queueHandle: ResourceHandle
-) -> (key: StringTensor, value: StringTensor) {
-  let op = TFE_Op("ReaderReadV2")
-  let _ = op.addInput(readerHandle)
-  let _ = op.addInput(queueHandle)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Restore a Reader to its initial clean state.
-///
-/// - Parameter reader_handle: Handle to a Reader.
-@inlinable
-public static func readerResetV2(
-  readerHandle: ResourceHandle
-) {
-  let op = TFE_Op("ReaderResetV2")
-  let _ = op.addInput(readerHandle)
-  op.execute()
-}
-
-/// Restore a reader to a previously saved state.
-///
-/// Not all Readers support being restored, so this can produce an
-/// Unimplemented error.
-///
-/// - Parameters:
-///   - reader_handle: Handle to a Reader.
-///   - state: Result of a ReaderSerializeState of a Reader with type
-///     matching reader_handle.
-@inlinable
-public static func readerRestoreStateV2(
-  readerHandle: ResourceHandle,
-  state: StringTensor
-) {
-  let op = TFE_Op("ReaderRestoreStateV2")
-  let _ = op.addInput(readerHandle)
-  let _ = op.addInput(state)
-  op.execute()
-}
-
-/// Produce a string tensor that encodes the state of a Reader.
-///
-/// Not all Readers support being serialized, so this can produce an
-/// Unimplemented error.
-///
-/// - Parameter reader_handle: Handle to a Reader.
-@inlinable
-public static func readerSerializeStateV2(
-  readerHandle: ResourceHandle
-) -> StringTensor {
-  let op = TFE_Op("ReaderSerializeStateV2")
-  let _ = op.addInput(readerHandle)
-  return op.execute(Int(1))
-}
-
-/// Returns the real part of a complex number.
-///
-/// Given a tensor `input` of complex numbers, this operation returns a tensor of
-/// type `float` that is the real part of each element in `input`. All elements in
-/// `input` must be complex numbers of the form \\(a + bj\\), where *a* is the real
-///  part returned by this operation and *b* is the imaginary part.
-///
-/// For example:
-///
-/// ```
-/// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
-/// tf.real(input) ==> [-2.25, 3.25]
-/// ```
-@inlinable
-public static func real<
-    T: TensorFlowScalar,
-    Tout: FloatingPoint & TensorFlowScalar
->(
-  _ input: Tensor<T>
-) -> Tensor<Tout> {
-  let op = TFE_Op("Real")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tout", Tout.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Returns x / y element-wise for real types.
-///
-/// If `x` and `y` are reals, this will return the floating-point division.
-///
-/// *NOTE*: `Div` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func realDiv<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("RealDiv")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Computes the reciprocal of x element-wise.
-///
-/// I.e., \\(y = 1 / x\\).
-@inlinable
-public static func reciprocal<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Reciprocal")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient for the inverse of `x` wrt its input.
-///
-/// Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy`
-/// is the corresponding input gradient.
-@inlinable
-public static func reciprocalGrad<T: FloatingPoint & TensorFlowScalar>(
-  _ y: Tensor<T>,
-  dy: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("ReciprocalGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(y)
-  let _ = op.addInput(dy)
-  return op.execute(Int(1))
-}
-
-/// Emits randomized records.
-///
-/// - Attrs:
-///   - file_pattern: Glob pattern for the data files.
-///   - file_random_seed: Random seeds used to produce randomized records.
-///   - file_shuffle_shift_ratio: Shifts the list of files after the list is randomly
-///     shuffled.
-///   - file_buffer_size: The randomization shuffling buffer.
-///   - file_parallelism: How many sstables are opened and concurrently iterated over.
-///   - batch_size: The batch size.
-///   - compression_type: The type of compression for the file. Currently ZLIB and
-///     GZIP are supported. Defaults to none.
-///
-/// - Output records: A tensor of shape [batch_size].
-@inlinable
-public static func recordInput(
-  filePattern: String,
-  fileRandomSeed: Int64 = 301,
-  fileShuffleShiftRatio: Double = 0,
-  fileBufferSize: Int64 = 10000,
-  fileParallelism: Int64 = 16,
-  batchSize: Int64 = 32,
-  compressionType: String
-) -> StringTensor {
-  let op = TFE_Op("RecordInput")
-  op.setAttr("file_pattern", filePattern)
-  op.setAttr("file_random_seed", fileRandomSeed)
-  op.setAttr("file_shuffle_shift_ratio", fileShuffleShiftRatio)
-  op.setAttr("file_buffer_size", fileBufferSize)
-  op.setAttr("file_parallelism", fileParallelism)
-  op.setAttr("batch_size", batchSize)
-  op.setAttr("compression_type", compressionType)
-  return op.execute(Int(1))
-}
-
-/// An op that receives embedding activations on the TPU.
-///
-/// The TPU system performs the embedding lookups and aggregations specified by
-/// the arguments to TPUEmbeddingEnqueue(Integer/Sparse/SparseTensor)Batch. The
-/// results of these aggregations are visible to the Tensorflow Graph as the
-/// outputs of a RecvTPUEmbeddingActivations op. This op returns a list containing
-/// one Tensor of activations per table specified in the model. There can be at
-/// most one RecvTPUEmbeddingActivations op in the TPU graph.
-///
-/// - Attrs:
-///   - num_outputs: The number of output activation tensors, equal to the number of
-///     embedding tables in the model.
-///   - config: Serialized TPUEmbeddingConfiguration proto.
-///
-/// - Output outputs: A TensorList of embedding activations containing one Tensor per
-///   embedding table in the model.
-@inlinable
-public static func recvTPUEmbeddingActivations(
-  numOutputs: Int64,
-  config: String
-) -> [Tensor<Float>] {
-  let op = TFE_Op("RecvTPUEmbeddingActivations")
-  op.setAttr("num_outputs", numOutputs)
-  op.setAttr("config", config)
-  return op.execute(Int(numOutputs))
-}
-
-/// Reduces the input dataset to a singleton using a reduce function.
-///
-/// - Parameters:
-///   - input_dataset: A variant tensor representing the input dataset.
-///   - initial_state: A nested structure of tensors, representing the initial state of the
-///     transformation.
-///
-/// - Attr f: A function that maps `(old_state, input_element)` to `new_state`. It must take
-///   two arguments and return a nested structures of tensors. The structure of
-///   `new_state` must match the structure of `initial_state`.
-@inlinable
-public static func reduceDataset<
-    FIn: TensorGroup,
-    FOut: TensorGroup,
-    Tstate: TensorArrayProtocol,
-    Targuments: TensorArrayProtocol,
-    OutputTypes: TensorGroup
->(
-  inputDataset: VariantHandle,
-  initialState: Tstate,
-  otherArguments: Targuments,
-  f: (FIn) -> FOut,
-  outputShapes: [TensorShape?],
-  useInterOpParallelism: Bool = true
-) -> OutputTypes {
-  let op = TFE_Op("ReduceDataset")
-  op.setAttr("f", f)
-  op.setAttr("Tstate", initialState._typeList)
-  op.setAttr("Targuments", otherArguments._typeList)
-  op.setAttr("output_types", OutputTypes._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("use_inter_op_parallelism", useInterOpParallelism)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInputList(initialState)
-  let _ = op.addInputList(otherArguments)
-  return op.execute(Int(OutputTypes._typeList.count))
-}
-
-/// Joins a string Tensor across the given dimensions.
-///
-/// Computes the string join across dimensions in the given string Tensor of shape
-/// `[\\(d_0, d_1, ..., d_{n-1}\\)]`.  Returns a new Tensor created by joining the input
-/// strings with the given separator (default: empty string).  Negative indices are
-/// counted backwards from the end, with `-1` being equivalent to `n - 1`.  If
-/// indices are not specified, joins across all dimensions beginning from `n - 1`
-/// through `0`.
-///
-/// For example:
-///
-/// ```python
-/// # tensor `a` is [["a", "b"], ["c", "d"]]
-/// tf.reduce_join(a, 0) ==> ["ac", "bd"]
-/// tf.reduce_join(a, 1) ==> ["ab", "cd"]
-/// tf.reduce_join(a, -2) = tf.reduce_join(a, 0) ==> ["ac", "bd"]
-/// tf.reduce_join(a, -1) = tf.reduce_join(a, 1) ==> ["ab", "cd"]
-/// tf.reduce_join(a, 0, keep_dims=True) ==> [["ac", "bd"]]
-/// tf.reduce_join(a, 1, keep_dims=True) ==> [["ab"], ["cd"]]
-/// tf.reduce_join(a, 0, separator=".") ==> ["a.c", "b.d"]
-/// tf.reduce_join(a, [0, 1]) ==> "acbd"
-/// tf.reduce_join(a, [1, 0]) ==> "abcd"
-/// tf.reduce_join(a, []) ==> [["a", "b"], ["c", "d"]]
-/// tf.reduce_join(a) = tf.reduce_join(a, [1, 0]) ==> "abcd"
-/// ```
-///
-/// - Parameters:
-///   - inputs: The input to be joined.  All reduced indices must have non-zero size.
-///   - reduction_indices: The dimensions to reduce over.  Dimensions are reduced in the
-///     order specified.  Omitting `reduction_indices` is equivalent to passing
-///     `[n-1, n-2, ..., 0]`.  Negative indices from `-n` to `-1` are supported.
-///
-/// - Attrs:
-///   - keep_dims: If `True`, retain reduced dimensions with length `1`.
-///   - separator: The separator to use when joining.
-///
-/// - Output output: Has shape equal to that of the input with reduced dimensions removed or
-///   set to `1` depending on `keep_dims`.
-@inlinable
-public static func reduceJoin(
-  inputs: StringTensor,
-  reductionIndices: Tensor<Int32>,
-  keepDims: Bool = false,
-  separator: String
-) -> StringTensor {
-  let op = TFE_Op("ReduceJoin")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("separator", separator)
-  let _ = op.addInput(inputs)
-  let _ = op.addInput(reductionIndices)
-  return op.execute(Int(1))
-}
-
-/// Check if the input matches the regex pattern.
-///
-/// The input is a string tensor of any shape. The pattern is a scalar
-/// string tensor which is applied to every element of the input tensor.
-/// The boolean values (True or False) of the output tensor indicate
-/// if the input matches the regex pattern provided.
-///
-/// The pattern follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
-///
-/// - Parameters:
-///   - input: A string tensor of the text to be processed.
-///   - pattern: A scalar string tensor containing the regular expression to match the input.
-///
-/// - Output output: A bool tensor with the same shape as `input`.
-@inlinable
-public static func regexFullMatch(
-  _ input: StringTensor,
-  pattern: StringTensor
-) -> Tensor<Bool> {
-  let op = TFE_Op("RegexFullMatch")
-  let _ = op.addInput(input)
-  let _ = op.addInput(pattern)
-  return op.execute(Int(1))
-}
-
-/// Replaces matches of the `pattern` regular expression in `input` with the
-/// replacement string provided in `rewrite`.
-///
-/// It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
-///
-/// - Parameters:
-///   - input: The text to be processed.
-///   - pattern: The regular expression to be matched in the `input` strings.
-///   - rewrite: The rewrite string to be substituted for the `pattern` expression where it is
-///     matched in the `input` strings.
-///
-/// - Attr replace_global: If True, the replacement is global (that is, all matches of the `pattern` regular
-///   expression in each input string are rewritten), otherwise the `rewrite`
-///   substitution is only made for the first `pattern` match.
-///
-/// - Output output: The text after applying pattern match and rewrite substitution.
-@inlinable
-public static func regexReplace(
-  _ input: StringTensor,
-  pattern: StringTensor,
-  rewrite: StringTensor,
-  replaceGlobal: Bool = true
-) -> StringTensor {
-  let op = TFE_Op("RegexReplace")
-  op.setAttr("replace_global", replaceGlobal)
-  let _ = op.addInput(input)
-  let _ = op.addInput(pattern)
-  let _ = op.addInput(rewrite)
-  return op.execute(Int(1))
-}
-
-/// Computes rectified linear: `max(features, 0)`.
-@inlinable
-public static func relu<T: Numeric & TensorFlowScalar>(
-  features: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Relu")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(features)
-  return op.execute(Int(1))
-}
-
-/// Computes rectified linear 6: `min(max(features, 0), 6)`.
-@inlinable
-public static func relu6<T: Numeric & TensorFlowScalar>(
-  features: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Relu6")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(features)
-  return op.execute(Int(1))
-}
-
-/// Computes rectified linear 6 gradients for a Relu6 operation.
-///
-/// - Parameters:
-///   - gradients: The backpropagated gradients to the corresponding Relu6 operation.
-///   - features: The features passed as input to the corresponding Relu6 operation, or
-///     its output; using either one produces the same result.
-///
-/// - Output backprops: The gradients:
-///   `gradients * (features > 0) * (features < 6)`.
-@inlinable
-public static func relu6Grad<T: Numeric & TensorFlowScalar>(
-  gradients: Tensor<T>,
-  features: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Relu6Grad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(gradients)
-  let _ = op.addInput(features)
-  return op.execute(Int(1))
-}
-
-/// Computes rectified linear gradients for a Relu operation.
-///
-/// - Parameters:
-///   - gradients: The backpropagated gradients to the corresponding Relu operation.
-///   - features: The features passed as input to the corresponding Relu operation, OR
-///     the outputs of that operation (both work equivalently).
-///
-/// - Output backprops: `gradients * (features > 0)`.
-@inlinable
-public static func reluGrad<T: Numeric & TensorFlowScalar>(
-  gradients: Tensor<T>,
-  features: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("ReluGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(gradients)
-  let _ = op.addInput(features)
-  return op.execute(Int(1))
-}
-
-/// Runs function `f` on a remote device indicated by `target`.
-///
-/// - Parameters:
-///   - target: A fully specified device name where we want to run the function.
-///   - args: A list of arguments for the function.
-///
-/// - Attrs:
-///   - Tin: The type list for the arguments.
-///   - Tout: The type list for the return values.
-///   - f: The function to run remotely.
-///
-/// - Output output: A list of return values.
-@inlinable
-public static func remoteCall<
-    Tin: TensorArrayProtocol,
-    Tout: TensorGroup,
-    FIn: TensorGroup,
-    FOut: TensorGroup
->(
-  target: StringTensor,
-  args: Tin,
-  f: (FIn) -> FOut
-) -> Tout {
-  let op = TFE_Op("RemoteCall")
-  op.setAttr("Tin", args._typeList)
-  op.setAttr("Tout", Tout._typeList)
-  op.setAttr("f", f)
-  let _ = op.addInput(target)
-  let _ = op.addInputList(args)
-  return op.execute(Int(Tout._typeList.count))
-}
-
-/// Execute a sub graph on a remote processor.
-///
-/// The graph specifications(such as graph itself, input tensors and output names)
-/// are stored as a serialized protocol buffer of RemoteFusedGraphExecuteInfo
-/// as serialized_remote_fused_graph_execute_info.
-/// The specifications will be passed to a dedicated registered
-/// remote fused graph executor.  The executor will send the graph specifications
-/// to a remote processor and execute that graph.  The execution results
-/// will be passed to consumer nodes as outputs of this node.
-///
-/// - Parameter inputs: Arbitrary number of tensors with arbitrary data types
-///
-/// - Attr serialized_remote_fused_graph_execute_info: Serialized protocol buffer
-///   of RemoteFusedGraphExecuteInfo which contains graph specifications.
-///
-/// - Output outputs: Arbitrary number of tensors with arbitrary data types
-@inlinable
-public static func remoteFusedGraphExecute<
-    Tinputs: TensorArrayProtocol,
-    Toutputs: TensorGroup
->(
-  inputs: Tinputs,
-  serializedRemoteFusedGraphExecuteInfo: String
-) -> Toutputs {
-  let op = TFE_Op("RemoteFusedGraphExecute")
-  op.setAttr("Tinputs", inputs._typeList)
-  op.setAttr("Toutputs", Toutputs._typeList)
-  op.setAttr("serialized_remote_fused_graph_execute_info", serializedRemoteFusedGraphExecuteInfo)
-  let _ = op.addInputList(inputs)
-  return op.execute(Int(Toutputs._typeList.count))
-}
-
-/// Creates a dataset that emits the outputs of `input_dataset` `count` times.
-///
-/// - Parameter count: A scalar representing the number of times that `input_dataset` should
-///   be repeated. A value of `-1` indicates that it should be repeated infinitely.
-@inlinable
-public static func repeatDataset(
-  inputDataset: VariantHandle,
-  count: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("RepeatDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(count)
-  return op.execute(Int(1))
-}
-
-/// Computes a range that covers the actual values present in a quantized tensor.
-///
-/// Given a quantized tensor described by `(input, input_min, input_max)`, outputs a
-/// range that covers the actual values present in that tensor. This op is typically
-/// used to produce the `requested_output_min` and `requested_output_max` for
-/// `Requantize`.
-///
-/// - Parameters:
-///   - input_min: The float value that the minimum quantized input value represents.
-///   - input_max: The float value that the maximum quantized input value represents.
-///
-/// - Attr Tinput: The type of the input.
-///
-/// - Outputs:
-///   - output_min: The computed min output.
-///   - output_max: the computed max output.
-@inlinable
-public static func requantizationRange<Tinput: TensorFlowScalar>(
-  _ input: Tensor<Tinput>,
-  inputMin: Tensor<Float>,
-  inputMax: Tensor<Float>
-) -> (outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
-  let op = TFE_Op("RequantizationRange")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputMin)
-  let _ = op.addInput(inputMax)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Computes requantization range per channel.
-///
-/// - Parameters:
-///   - input: The original input tensor.
-///   - input_min: The minimum value of the input tensor
-///   - input_max: The maximum value of the input tensor.
-///
-/// - Attrs:
-///   - T: The quantized type of input tensor that needs to be converted. 
-///   - clip_value_max: The maximum value of the output that needs to be clipped.
-///     Example: set this to 6 for Relu6. 
-///
-/// - Outputs:
-///   - output_min: The minimum value of the final output tensor
-///   - output_max: The maximum value of the final output tensor.
-@inlinable
-public static func requantizationRangePerChannel<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  inputMin: Tensor<Float>,
-  inputMax: Tensor<Float>,
-  clipValueMax: Double
-) -> (outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
-  let op = TFE_Op("RequantizationRangePerChannel")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("clip_value_max", clipValueMax)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputMin)
-  let _ = op.addInput(inputMax)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Converts the quantized `input` tensor into a lower-precision `output`.
-///
-/// Converts the quantized `input` tensor into a lower-precision `output`, using the
-/// output range specified with `requested_output_min` and `requested_output_max`.
-///
-/// `[input_min, input_max]` are scalar floats that specify the range for the float
-/// interpretation of the `input` data. For example, if `input_min` is -1.0f and
-/// `input_max` is 1.0f, and we are dealing with `quint16` quantized data, then a 0
-/// value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.
-///
-/// - Parameters:
-///   - input_min: The float value that the minimum quantized input value represents.
-///   - input_max: The float value that the maximum quantized input value represents.
-///   - requested_output_min: The float value that the minimum quantized output value represents.
-///   - requested_output_max: The float value that the maximum quantized output value represents.
-///
-/// - Attrs:
-///   - Tinput: The type of the input.
-///   - out_type: The type of the output. Should be a lower bit depth than Tinput.
-///
-/// - Outputs:
-///   - output_min: The requested_output_min value is copied into this output.
-///   - output_max: The requested_output_max value is copied into this output.
-@inlinable
-public static func requantize<
-    Tinput: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<Tinput>,
-  inputMin: Tensor<Float>,
-  inputMax: Tensor<Float>,
-  requestedOutputMin: Tensor<Float>,
-  requestedOutputMax: Tensor<Float>
-) -> (output: Tensor<OutType>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
-  let op = TFE_Op("Requantize")
-  op.setAttr("Tinput", Tinput.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputMin)
-  let _ = op.addInput(inputMax)
-  let _ = op.addInput(requestedOutputMin)
-  let _ = op.addInput(requestedOutputMax)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Requantizes input with min and max values known per channel.
-///
-/// - Parameters:
-///   - input: The original input tensor.
-///   - input_min: The minimum value of the input tensor
-///   - input_max: The maximum value of the input tensor.
-///   - requested_output_min: The minimum value of the output tensor requested.
-///   - requested_output_max: The maximum value of the output tensor requested.
-///
-/// - Attrs:
-///   - T: The quantized type of input tensor that needs to be converted. 
-///   - out_type: The quantized type of output tensor that needs to be converted.
-///
-/// - Outputs:
-///   - output: Output tensor.
-///   - output_min: The minimum value of the final output tensor
-///   - output_max: The maximum value of the final output tensor.
-@inlinable
-public static func requantizePerChannel<
-    T: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  inputMin: Tensor<Float>,
-  inputMax: Tensor<Float>,
-  requestedOutputMin: Tensor<Float>,
-  requestedOutputMax: Tensor<Float>
-) -> (output: Tensor<OutType>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
-  let op = TFE_Op("RequantizePerChannel")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(inputMin)
-  let _ = op.addInput(inputMax)
-  let _ = op.addInput(requestedOutputMin)
-  let _ = op.addInput(requestedOutputMax)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func requiresOlderGraphVersion(
-) -> Tensor<Int32> {
-  let op = TFE_Op("RequiresOlderGraphVersion")
-  
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func reservedAttr(
-  range: Int64
-) {
-  let op = TFE_Op("ReservedAttr")
-  op.setAttr("range", range)
-  op.execute()
-}
-
-@inlinable
-public static func reservedInput(
-  _ input: Tensor<Int32>
-) {
-  let op = TFE_Op("ReservedInput")
-  let _ = op.addInput(input)
-  op.execute()
-}
-
-/// Reshapes a tensor.
-///
-/// Given `tensor`, this operation returns a tensor that has the same values
-/// as `tensor` with shape `shape`.
-///
-/// If one component of `shape` is the special value -1, the size of that dimension
-/// is computed so that the total size remains constant.  In particular, a `shape`
-/// of `[-1]` flattens into 1-D.  At most one component of `shape` can be -1.
-///
-/// If `shape` is 1-D or higher, then the operation returns a tensor with shape
-/// `shape` filled with the values of `tensor`. In this case, the number of elements
-/// implied by `shape` must be the same as the number of elements in `tensor`.
-///
-/// For example:
-///
-/// ```
-/// # tensor 't' is [1, 2, 3, 4, 5, 6, 7, 8, 9]
-/// # tensor 't' has shape [9]
-/// reshape(t, [3, 3]) ==> [[1, 2, 3],
-///                         [4, 5, 6],
-///                         [7, 8, 9]]
-///
-/// # tensor 't' is [[[1, 1], [2, 2]],
-/// #                [[3, 3], [4, 4]]]
-/// # tensor 't' has shape [2, 2, 2]
-/// reshape(t, [2, 4]) ==> [[1, 1, 2, 2],
-///                         [3, 3, 4, 4]]
-///
-/// # tensor 't' is [[[1, 1, 1],
-/// #                 [2, 2, 2]],
-/// #                [[3, 3, 3],
-/// #                 [4, 4, 4]],
-/// #                [[5, 5, 5],
-/// #                 [6, 6, 6]]]
-/// # tensor 't' has shape [3, 2, 3]
-/// # pass '[-1]' to flatten 't'
-/// reshape(t, [-1]) ==> [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]
-///
-/// # -1 can also be used to infer the shape
-///
-/// # -1 is inferred to be 9:
-/// reshape(t, [2, -1]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
-///                          [4, 4, 4, 5, 5, 5, 6, 6, 6]]
-/// # -1 is inferred to be 2:
-/// reshape(t, [-1, 9]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
-///                          [4, 4, 4, 5, 5, 5, 6, 6, 6]]
-/// # -1 is inferred to be 3:
-/// reshape(t, [ 2, -1, 3]) ==> [[[1, 1, 1],
-///                               [2, 2, 2],
-///                               [3, 3, 3]],
-///                              [[4, 4, 4],
-///                               [5, 5, 5],
-///                               [6, 6, 6]]]
-///
-/// # tensor 't' is [7]
-/// # shape `[]` reshapes to a scalar
-/// reshape(t, []) ==> 7
-/// ```
-///
-/// - Parameter shape: Defines the shape of the output tensor.
-@inlinable
-public static func reshape<
-    T: TensorFlowScalar,
-    Tshape: BinaryInteger & TensorFlowScalar
->(
-  _ tensor: Tensor<T>,
-  shape: Tensor<Tshape>
-) -> Tensor<T> {
-  let op = TFE_Op("Reshape")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tshape", Tshape.tensorFlowDataType)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Resize `images` to `size` using area interpolation.
-///
-/// Input images can be of different types but output images are always float.
-///
-/// The range of pixel values for the output image might be slightly different
-/// from the range for the input image because of limited numerical precision.
-/// To guarantee an output range, for example `[0.0, 1.0]`, apply
-/// `tf.clip_by_value` to the output.
-///
-/// Each output pixel is computed by first transforming the pixel's footprint into
-/// the input tensor and then averaging the pixels that intersect the footprint. An
-/// input pixel's contribution to the average is weighted by the fraction of its
-/// area that intersects the footprint.  This is the same as OpenCV's INTER_AREA.
-///
-/// - Parameters:
-///   - images: 4-D with shape `[batch, height, width, channels]`.
-///   - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
-///     new size for the images.
-///
-/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
-///   aligned, preserving the values at the corner pixels. Defaults to false.
-///
-/// - Output resized_images: 4-D with shape
-///   `[batch, new_height, new_width, channels]`.
-@inlinable
-public static func resizeArea<T: Numeric & TensorFlowScalar>(
-  images: Tensor<T>,
-  size: Tensor<Int32>,
-  alignCorners: Bool = false
-) -> Tensor<Float> {
-  let op = TFE_Op("ResizeArea")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("align_corners", alignCorners)
-  let _ = op.addInput(images)
-  let _ = op.addInput(size)
-  return op.execute(Int(1))
-}
-
-/// Resize `images` to `size` using bicubic interpolation.
-///
-/// Input images can be of different types but output images are always float.
-///
-/// - Parameters:
-///   - images: 4-D with shape `[batch, height, width, channels]`.
-///   - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
-///     new size for the images.
-///
-/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
-///   aligned, preserving the values at the corner pixels. Defaults to false.
-///
-/// - Output resized_images: 4-D with shape
-///   `[batch, new_height, new_width, channels]`.
-@inlinable
-public static func resizeBicubic<T: Numeric & TensorFlowScalar>(
-  images: Tensor<T>,
-  size: Tensor<Int32>,
-  alignCorners: Bool = false,
-  halfPixelCenters: Bool = false
-) -> Tensor<Float> {
-  let op = TFE_Op("ResizeBicubic")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("align_corners", alignCorners)
-  op.setAttr("half_pixel_centers", halfPixelCenters)
-  let _ = op.addInput(images)
-  let _ = op.addInput(size)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient of bicubic interpolation.
-///
-/// - Parameters:
-///   - grads: 4-D with shape `[batch, height, width, channels]`.
-///   - original_image: 4-D with shape `[batch, orig_height, orig_width, channels]`,
-///     The image tensor that was resized.
-///
-/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and grad tensors are
-///   aligned. Defaults to false.
-///
-/// - Output output: 4-D with shape `[batch, orig_height, orig_width, channels]`.
-///   Gradients with respect to the input image. Input image must have been
-///   float or double.
-@inlinable
-public static func resizeBicubicGrad<T: FloatingPoint & TensorFlowScalar>(
-  grads: Tensor<Float>,
-  originalImage: Tensor<T>,
-  alignCorners: Bool = false,
-  halfPixelCenters: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("ResizeBicubicGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("align_corners", alignCorners)
-  op.setAttr("half_pixel_centers", halfPixelCenters)
-  let _ = op.addInput(grads)
-  let _ = op.addInput(originalImage)
-  return op.execute(Int(1))
-}
-
-/// Resize `images` to `size` using bilinear interpolation.
-///
-/// Input images can be of different types but output images are always float.
-///
-/// - Parameters:
-///   - images: 4-D with shape `[batch, height, width, channels]`.
-///   - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
-///     new size for the images.
-///
-/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
-///   aligned, preserving the values at the corner pixels. Defaults to false.
-///
-/// - Output resized_images: 4-D with shape
-///   `[batch, new_height, new_width, channels]`.
-@inlinable
-public static func resizeBilinear<T: Numeric & TensorFlowScalar>(
-  images: Tensor<T>,
-  size: Tensor<Int32>,
-  alignCorners: Bool = false,
-  halfPixelCenters: Bool = false
-) -> Tensor<Float> {
-  let op = TFE_Op("ResizeBilinear")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("align_corners", alignCorners)
-  op.setAttr("half_pixel_centers", halfPixelCenters)
-  let _ = op.addInput(images)
-  let _ = op.addInput(size)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient of bilinear interpolation.
-///
-/// - Parameters:
-///   - grads: 4-D with shape `[batch, height, width, channels]`.
-///   - original_image: 4-D with shape `[batch, orig_height, orig_width, channels]`,
-///     The image tensor that was resized.
-///
-/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and grad tensors are
-///   aligned. Defaults to false.
-///
-/// - Output output: 4-D with shape `[batch, orig_height, orig_width, channels]`.
-///   Gradients with respect to the input image. Input image must have been
-///   float or double.
-@inlinable
-public static func resizeBilinearGrad<T: FloatingPoint & TensorFlowScalar>(
-  grads: Tensor<Float>,
-  originalImage: Tensor<T>,
-  alignCorners: Bool = false,
-  halfPixelCenters: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("ResizeBilinearGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("align_corners", alignCorners)
-  op.setAttr("half_pixel_centers", halfPixelCenters)
-  let _ = op.addInput(grads)
-  let _ = op.addInput(originalImage)
-  return op.execute(Int(1))
-}
-
-/// Resize `images` to `size` using nearest neighbor interpolation.
-///
-/// - Parameters:
-///   - images: 4-D with shape `[batch, height, width, channels]`.
-///   - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
-///     new size for the images.
-///
-/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
-///   aligned, preserving the values at the corner pixels. Defaults to false.
-///
-/// - Output resized_images: 4-D with shape
-///   `[batch, new_height, new_width, channels]`.
-@inlinable
-public static func resizeNearestNeighbor<T: Numeric & TensorFlowScalar>(
-  images: Tensor<T>,
-  size: Tensor<Int32>,
-  alignCorners: Bool = false,
-  halfPixelCenters: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("ResizeNearestNeighbor")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("align_corners", alignCorners)
-  op.setAttr("half_pixel_centers", halfPixelCenters)
-  let _ = op.addInput(images)
-  let _ = op.addInput(size)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient of nearest neighbor interpolation.
-///
-/// - Parameters:
-///   - grads: 4-D with shape `[batch, height, width, channels]`.
-///   - size: = A 1-D int32 Tensor of 2 elements: `orig_height, orig_width`. The
-///     original input size.
-///
-/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and grad tensors are
-///   aligned. Defaults to false.
-///
-/// - Output output: 4-D with shape `[batch, orig_height, orig_width, channels]`. Gradients
-///   with respect to the input image.
-@inlinable
-public static func resizeNearestNeighborGrad<T: Numeric & TensorFlowScalar>(
-  grads: Tensor<T>,
-  size: Tensor<Int32>,
-  alignCorners: Bool = false,
-  halfPixelCenters: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("ResizeNearestNeighborGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("align_corners", alignCorners)
-  op.setAttr("half_pixel_centers", halfPixelCenters)
-  let _ = op.addInput(grads)
-  let _ = op.addInput(size)
-  return op.execute(Int(1))
-}
-
-/// Update '*var' according to the AdaMax algorithm.
-///
-/// m_t <- beta1 * m_{t-1} + (1 - beta1) * g
-/// v_t <- max(beta2 * v_{t-1}, abs(g))
-/// variable <- variable - learning_rate / (1 - beta1^t) * m_t / (v_t + epsilon)
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - m: Should be from a Variable().
-///   - v: Should be from a Variable().
-///   - beta1_power: Must be a scalar.
-///   - lr: Scaling factor. Must be a scalar.
-///   - beta1: Momentum factor. Must be a scalar.
-///   - beta2: Momentum factor. Must be a scalar.
-///   - epsilon: Ridge term. Must be a scalar.
-///   - grad: The gradient.
-///
-/// - Attr use_locking: If `True`, updating of the var, m, and v tensors will be protected
-///   by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceApplyAdaMax<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  m: ResourceHandle,
-  v: ResourceHandle,
-  beta1Power: Tensor<T>,
-  lr: Tensor<T>,
-  beta1: Tensor<T>,
-  beta2: Tensor<T>,
-  epsilon: Tensor<T>,
-  grad: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyAdaMax")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(m)
-  let _ = op.addInput(v)
-  let _ = op.addInput(beta1Power)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(beta1)
-  let _ = op.addInput(beta2)
-  let _ = op.addInput(epsilon)
-  let _ = op.addInput(grad)
-  op.execute()
-}
-
-/// Update '*var' according to the adadelta scheme.
-///
-/// accum = rho() * accum + (1 - rho()) * grad.square();
-/// update = (update_accum + epsilon).sqrt() * (accum + epsilon()).rsqrt() * grad;
-/// update_accum = rho() * update_accum + (1 - rho()) * update.square();
-/// var -= update;
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - accum_update: Should be from a Variable().
-///   - lr: Scaling factor. Must be a scalar.
-///   - rho: Decay factor. Must be a scalar.
-///   - epsilon: Constant factor. Must be a scalar.
-///   - grad: The gradient.
-///
-/// - Attr use_locking: If True, updating of the var, accum and update_accum tensors will be protected by
-///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable
-public static func resourceApplyAdadelta<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  accumUpdate: ResourceHandle,
-  lr: Tensor<T>,
-  rho: Tensor<T>,
-  epsilon: Tensor<T>,
-  grad: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyAdadelta")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(accumUpdate)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(rho)
-  let _ = op.addInput(epsilon)
-  let _ = op.addInput(grad)
-  op.execute()
-}
-
-/// Update '*var' according to the adagrad scheme.
-///
-/// accum += grad * grad
-/// var -= lr * grad * (1 / sqrt(accum))
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - lr: Scaling factor. Must be a scalar.
-///   - grad: The gradient.
-///
-/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
-///   by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceApplyAdagrad<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  lr: Tensor<T>,
-  grad: Tensor<T>,
-  useLocking: Bool = false,
-  updateSlots: Bool = true
-) {
-  let op = TFE_Op("ResourceApplyAdagrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  op.setAttr("update_slots", updateSlots)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(grad)
-  op.execute()
-}
-
-/// Update '*var' according to the proximal adagrad scheme.
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - gradient_accumulator: Should be from a Variable().
-///   - gradient_squared_accumulator: Should be from a Variable().
-///   - grad: The gradient.
-///   - lr: Scaling factor. Must be a scalar.
-///   - l1: L1 regularization. Must be a scalar.
-///   - l2: L2 regularization. Must be a scalar.
-///   - global_step: Training step number. Must be a scalar.
-///
-/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
-///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable
-public static func resourceApplyAdagradDA<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  gradientAccumulator: ResourceHandle,
-  gradientSquaredAccumulator: ResourceHandle,
-  grad: Tensor<T>,
-  lr: Tensor<T>,
-  l1: Tensor<T>,
-  l2: Tensor<T>,
-  globalStep: Tensor<Int64>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyAdagradDA")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(gradientAccumulator)
-  let _ = op.addInput(gradientSquaredAccumulator)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  let _ = op.addInput(globalStep)
-  op.execute()
-}
-
-/// Update '*var' according to the Adam algorithm.
-///
-/// $$lr_t := \text{learning\_rate} * \sqrt{1 - beta_2^t} / (1 - beta_1^t)$$
-/// $$m_t := beta_1 * m_{t-1} + (1 - beta_1) * g$$
-/// $$v_t := beta_2 * v_{t-1} + (1 - beta_2) * g * g$$
-/// $$variable := variable - lr_t * m_t / (\sqrt{v_t} + \epsilon)$$
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - m: Should be from a Variable().
-///   - v: Should be from a Variable().
-///   - beta1_power: Must be a scalar.
-///   - beta2_power: Must be a scalar.
-///   - lr: Scaling factor. Must be a scalar.
-///   - beta1: Momentum factor. Must be a scalar.
-///   - beta2: Momentum factor. Must be a scalar.
-///   - epsilon: Ridge term. Must be a scalar.
-///   - grad: The gradient.
-///
-/// - Attrs:
-///   - use_locking: If `True`, updating of the var, m, and v tensors will be protected
-///     by a lock; otherwise the behavior is undefined, but may exhibit less
-///     contention.
-///   - use_nesterov: If `True`, uses the nesterov update.
-@inlinable
-public static func resourceApplyAdam<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  m: ResourceHandle,
-  v: ResourceHandle,
-  beta1Power: Tensor<T>,
-  beta2Power: Tensor<T>,
-  lr: Tensor<T>,
-  beta1: Tensor<T>,
-  beta2: Tensor<T>,
-  epsilon: Tensor<T>,
-  grad: Tensor<T>,
-  useLocking: Bool = false,
-  useNesterov: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyAdam")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  op.setAttr("use_nesterov", useNesterov)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(m)
-  let _ = op.addInput(v)
-  let _ = op.addInput(beta1Power)
-  let _ = op.addInput(beta2Power)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(beta1)
-  let _ = op.addInput(beta2)
-  let _ = op.addInput(epsilon)
-  let _ = op.addInput(grad)
-  op.execute()
-}
-
-/// Update '*var' according to the Adam algorithm.
-///
-/// $$lr_t := \text{learning\_rate} * \sqrt{1 - beta_2^t} / (1 - beta_1^t)$$
-/// $$m_t := beta_1 * m_{t-1} + (1 - beta_1) * g$$
-/// $$v_t := beta_2 * v_{t-1} + (1 - beta_2) * g * g$$
-/// $$vhat_t := max{vhat_{t-1}, v_t}$$
-/// $$variable := variable - lr_t * m_t / (\sqrt{vhat_t} + \epsilon)$$
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - m: Should be from a Variable().
-///   - v: Should be from a Variable().
-///   - vhat: Should be from a Variable().
-///   - beta1_power: Must be a scalar.
-///   - beta2_power: Must be a scalar.
-///   - lr: Scaling factor. Must be a scalar.
-///   - beta1: Momentum factor. Must be a scalar.
-///   - beta2: Momentum factor. Must be a scalar.
-///   - epsilon: Ridge term. Must be a scalar.
-///   - grad: The gradient.
-///
-/// - Attr use_locking: If `True`, updating of the var, m, and v tensors will be protected
-///   by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceApplyAdamWithAmsgrad<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  m: ResourceHandle,
-  v: ResourceHandle,
-  vhat: ResourceHandle,
-  beta1Power: Tensor<T>,
-  beta2Power: Tensor<T>,
-  lr: Tensor<T>,
-  beta1: Tensor<T>,
-  beta2: Tensor<T>,
-  epsilon: Tensor<T>,
-  grad: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyAdamWithAmsgrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(m)
-  let _ = op.addInput(v)
-  let _ = op.addInput(vhat)
-  let _ = op.addInput(beta1Power)
-  let _ = op.addInput(beta2Power)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(beta1)
-  let _ = op.addInput(beta2)
-  let _ = op.addInput(epsilon)
-  let _ = op.addInput(grad)
-  op.execute()
-}
-
-/// Update '*var' according to the AddSign update.
-///
-/// m_t <- beta1 * m_{t-1} + (1 - beta1) * g
-/// update <- (alpha + sign_decay * sign(g) *sign(m)) * g
-/// variable <- variable - lr_t * update
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - m: Should be from a Variable().
-///   - lr: Scaling factor. Must be a scalar.
-///   - alpha: Must be a scalar.
-///   - sign_decay: Must be a scalar.
-///   - beta: Must be a scalar.
-///   - grad: The gradient.
-///
-/// - Attr use_locking: If `True`, updating of the var and m tensors is
-///   protected by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceApplyAddSign<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  m: ResourceHandle,
-  lr: Tensor<T>,
-  alpha: Tensor<T>,
-  signDecay: Tensor<T>,
-  beta: Tensor<T>,
-  grad: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyAddSign")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(m)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(alpha)
-  let _ = op.addInput(signDecay)
-  let _ = op.addInput(beta)
-  let _ = op.addInput(grad)
-  op.execute()
-}
-
-/// Update '*var' according to the centered RMSProp algorithm.
-///
-/// The centered RMSProp algorithm uses an estimate of the centered second moment
-/// (i.e., the variance) for normalization, as opposed to regular RMSProp, which
-/// uses the (uncentered) second moment. This often helps with training, but is
-/// slightly more expensive in terms of computation and memory.
-///
-/// Note that in dense implementation of this algorithm, mg, ms, and mom will
-/// update even if the grad is zero, but in this sparse implementation, mg, ms,
-/// and mom will not update in iterations during which the grad is zero.
-///
-/// mean_square = decay * mean_square + (1-decay) * gradient ** 2
-/// mean_grad = decay * mean_grad + (1-decay) * gradient
-///
-/// Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
-///
-/// mg <- rho * mg_{t-1} + (1-rho) * grad
-/// ms <- rho * ms_{t-1} + (1-rho) * grad * grad
-/// mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms - mg * mg + epsilon)
-/// var <- var - mom
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - mg: Should be from a Variable().
-///   - ms: Should be from a Variable().
-///   - mom: Should be from a Variable().
-///   - lr: Scaling factor. Must be a scalar.
-///   - rho: Decay rate. Must be a scalar.
-///   - epsilon: Ridge term. Must be a scalar.
-///   - grad: The gradient.
-///
-/// - Attr use_locking: If `True`, updating of the var, mg, ms, and mom tensors is
-///   protected by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceApplyCenteredRMSProp<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  mg: ResourceHandle,
-  ms: ResourceHandle,
-  mom: ResourceHandle,
-  lr: Tensor<T>,
-  rho: Tensor<T>,
-  momentum: Tensor<T>,
-  epsilon: Tensor<T>,
-  grad: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyCenteredRMSProp")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(mg)
-  let _ = op.addInput(ms)
-  let _ = op.addInput(mom)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(rho)
-  let _ = op.addInput(momentum)
-  let _ = op.addInput(epsilon)
-  let _ = op.addInput(grad)
-  op.execute()
-}
-
-/// Update '*var' according to the Ftrl-proximal scheme.
-///
-/// accum_new = accum + grad * grad
-/// linear += grad - (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
-/// quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
-/// var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
-/// accum = accum_new
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - linear: Should be from a Variable().
-///   - grad: The gradient.
-///   - lr: Scaling factor. Must be a scalar.
-///   - l1: L1 regulariation. Must be a scalar.
-///   - l2: L2 regulariation. Must be a scalar.
-///   - lr_power: Scaling factor. Must be a scalar.
-///
-/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
-///   by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceApplyFtrl<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  linear: ResourceHandle,
-  grad: Tensor<T>,
-  lr: Tensor<T>,
-  l1: Tensor<T>,
-  l2: Tensor<T>,
-  lrPower: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyFtrl")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(linear)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  let _ = op.addInput(lrPower)
-  op.execute()
-}
-
-/// Update '*var' according to the Ftrl-proximal scheme.
-///
-/// grad_with_shrinkage = grad + 2 * l2_shrinkage * var
-/// accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
-/// linear += grad_with_shrinkage +
-///     (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
-/// quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
-/// var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
-/// accum = accum_new
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - linear: Should be from a Variable().
-///   - grad: The gradient.
-///   - lr: Scaling factor. Must be a scalar.
-///   - l1: L1 regulariation. Must be a scalar.
-///   - l2: L2 shrinkage regulariation. Must be a scalar.
-///   - lr_power: Scaling factor. Must be a scalar.
-///
-/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
-///   by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceApplyFtrlV2<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  linear: ResourceHandle,
-  grad: Tensor<T>,
-  lr: Tensor<T>,
-  l1: Tensor<T>,
-  l2: Tensor<T>,
-  l2Shrinkage: Tensor<T>,
-  lrPower: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyFtrlV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(linear)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  let _ = op.addInput(l2Shrinkage)
-  let _ = op.addInput(lrPower)
-  op.execute()
-}
-
-/// Update '*var' by subtracting 'alpha' * 'delta' from it.
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - alpha: Scaling factor. Must be a scalar.
-///   - delta: The change.
-///
-/// - Attr use_locking: If `True`, the subtraction will be protected by a lock;
-///   otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable
-public static func resourceApplyGradientDescent<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  alpha: Tensor<T>,
-  delta: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyGradientDescent")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(alpha)
-  let _ = op.addInput(delta)
-  op.execute()
-}
-
-/// Update '*var' according to the momentum scheme. Set use_nesterov = True if you
-///
-/// want to use Nesterov momentum.
-///
-/// accum = accum * momentum - lr * grad
-/// var += accum
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - lr: Scaling factor. Must be a scalar.
-///   - grad: The gradient.
-///   - momentum: Momentum. Must be a scalar.
-///
-/// - Attrs:
-///   - use_locking: If `True`, updating of the var and accum tensors will be protected
-///     by a lock; otherwise the behavior is undefined, but may exhibit less
-///     contention.
-///   - use_nesterov: If `True`, the tensor passed to compute grad will be
-///     var + momentum * accum, so in the end, the var you get is actually
-///     var + momentum * accum.
-@inlinable
-public static func resourceApplyKerasMomentum<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  lr: Tensor<T>,
-  grad: Tensor<T>,
-  momentum: Tensor<T>,
-  useLocking: Bool = false,
-  useNesterov: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyKerasMomentum")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  op.setAttr("use_nesterov", useNesterov)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(momentum)
-  op.execute()
-}
-
-/// Update '*var' according to the momentum scheme. Set use_nesterov = True if you
-///
-/// want to use Nesterov momentum.
-///
-/// accum = accum * momentum + grad
-/// var -= lr * accum
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - lr: Scaling factor. Must be a scalar.
-///   - grad: The gradient.
-///   - momentum: Momentum. Must be a scalar.
-///
-/// - Attrs:
-///   - use_locking: If `True`, updating of the var and accum tensors will be protected
-///     by a lock; otherwise the behavior is undefined, but may exhibit less
-///     contention.
-///   - use_nesterov: If `True`, the tensor passed to compute grad will be
-///     var - lr * momentum * accum, so in the end, the var you get is actually
-///     var - lr * momentum * accum.
-@inlinable
-public static func resourceApplyMomentum<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  lr: Tensor<T>,
-  grad: Tensor<T>,
-  momentum: Tensor<T>,
-  useLocking: Bool = false,
-  useNesterov: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyMomentum")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  op.setAttr("use_nesterov", useNesterov)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(momentum)
-  op.execute()
-}
-
-/// Update '*var' according to the AddSign update.
-///
-/// m_t <- beta1 * m_{t-1} + (1 - beta1) * g
-/// update <- exp(logbase * sign_decay * sign(g) * sign(m_t)) * g
-/// variable <- variable - lr_t * update
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - m: Should be from a Variable().
-///   - lr: Scaling factor. Must be a scalar.
-///   - logbase: Must be a scalar.
-///   - sign_decay: Must be a scalar.
-///   - beta: Must be a scalar.
-///   - grad: The gradient.
-///
-/// - Attr use_locking: If `True`, updating of the var and m tensors is
-///   protected by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceApplyPowerSign<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  m: ResourceHandle,
-  lr: Tensor<T>,
-  logbase: Tensor<T>,
-  signDecay: Tensor<T>,
-  beta: Tensor<T>,
-  grad: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyPowerSign")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(m)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(logbase)
-  let _ = op.addInput(signDecay)
-  let _ = op.addInput(beta)
-  let _ = op.addInput(grad)
-  op.execute()
-}
-
-/// Update '*var' and '*accum' according to FOBOS with Adagrad learning rate.
-///
-/// accum += grad * grad
-/// prox_v = var - lr * grad * (1 / sqrt(accum))
-/// var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - lr: Scaling factor. Must be a scalar.
-///   - l1: L1 regularization. Must be a scalar.
-///   - l2: L2 regularization. Must be a scalar.
-///   - grad: The gradient.
-///
-/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
-///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable
-public static func resourceApplyProximalAdagrad<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  lr: Tensor<T>,
-  l1: Tensor<T>,
-  l2: Tensor<T>,
-  grad: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyProximalAdagrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  let _ = op.addInput(grad)
-  op.execute()
-}
-
-/// Update '*var' as FOBOS algorithm with fixed learning rate.
-///
-/// prox_v = var - alpha * delta
-/// var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - alpha: Scaling factor. Must be a scalar.
-///   - l1: L1 regularization. Must be a scalar.
-///   - l2: L2 regularization. Must be a scalar.
-///   - delta: The change.
-///
-/// - Attr use_locking: If True, the subtraction will be protected by a lock;
-///   otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable
-public static func resourceApplyProximalGradientDescent<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  alpha: Tensor<T>,
-  l1: Tensor<T>,
-  l2: Tensor<T>,
-  delta: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyProximalGradientDescent")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(alpha)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  let _ = op.addInput(delta)
-  op.execute()
-}
-
-/// Update '*var' according to the RMSProp algorithm.
-///
-/// Note that in dense implementation of this algorithm, ms and mom will
-/// update even if the grad is zero, but in this sparse implementation, ms
-/// and mom will not update in iterations during which the grad is zero.
-///
-/// mean_square = decay * mean_square + (1-decay) * gradient ** 2
-/// Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
-///
-/// ms <- rho * ms_{t-1} + (1-rho) * grad * grad
-/// mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
-/// var <- var - mom
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - ms: Should be from a Variable().
-///   - mom: Should be from a Variable().
-///   - lr: Scaling factor. Must be a scalar.
-///   - rho: Decay rate. Must be a scalar.
-///   - epsilon: Ridge term. Must be a scalar.
-///   - grad: The gradient.
-///
-/// - Attr use_locking: If `True`, updating of the var, ms, and mom tensors is protected
-///   by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceApplyRMSProp<T: Numeric & TensorFlowScalar>(
-  var_: ResourceHandle,
-  ms: ResourceHandle,
-  mom: ResourceHandle,
-  lr: Tensor<T>,
-  rho: Tensor<T>,
-  momentum: Tensor<T>,
-  epsilon: Tensor<T>,
-  grad: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceApplyRMSProp")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(ms)
-  let _ = op.addInput(mom)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(rho)
-  let _ = op.addInput(momentum)
-  let _ = op.addInput(epsilon)
-  let _ = op.addInput(grad)
-  op.execute()
-}
-
-/// Increments variable pointed to by 'resource' until it reaches 'limit'.
-///
-/// - Parameter resource: Should be from a scalar `Variable` node.
-///
-/// - Attr limit: If incrementing ref would bring it above limit, instead generates an
-///   'OutOfRange' error.
-///
-/// - Output output: A copy of the input before increment. If nothing else modifies the
-///   input, the values produced will all be distinct.
-@inlinable
-public static func resourceCountUpTo<T: BinaryInteger & TensorFlowScalar>(
-  resource: ResourceHandle,
-  limit: Int64
-) -> Tensor<T> {
-  let op = TFE_Op("ResourceCountUpTo")
-  op.setAttr("limit", limit)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func resourceCreateOp(
-  resource: ResourceHandle
-) {
-  let op = TFE_Op("ResourceCreateOp")
-  let _ = op.addInput(resource)
-  op.execute()
-}
-
-/// Gather slices from the variable pointed to by `resource` according to `indices`.
-///
-/// `indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
-/// Produces an output tensor with shape `indices.shape + params.shape[1:]` where:
-///
-/// ```python
-///     # Scalar indices
-///     output[:, ..., :] = params[indices, :, ... :]
-///
-///     # Vector indices
-///     output[i, :, ..., :] = params[indices[i], :, ... :]
-///
-///     # Higher rank indices
-///     output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
-/// ```
-@inlinable
-public static func resourceGather<
-    Dtype: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  resource: ResourceHandle,
-  indices: Tensor<Tindices>,
-  batchDims: Int64 = 0,
-  validateIndices: Bool = true
-) -> Tensor<Dtype> {
-  let op = TFE_Op("ResourceGather")
-  op.setAttr("batch_dims", batchDims)
-  op.setAttr("validate_indices", validateIndices)
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(indices)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func resourceGatherNd<
-    Dtype: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  resource: ResourceHandle,
-  indices: Tensor<Tindices>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("ResourceGatherNd")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(indices)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func resourceInitializedOp(
-  resource: ResourceHandle
-) -> Tensor<Bool> {
-  let op = TFE_Op("ResourceInitializedOp")
-  let _ = op.addInput(resource)
-  return op.execute(Int(1))
-}
-
-/// Adds sparse updates to the variable referenced by `resource`.
-///
-/// This operation computes
-///
-///     # Scalar indices
-///     ref[indices, ...] += updates[...]
-///
-///     # Vector indices (for each i)
-///     ref[indices[i], ...] += updates[i, ...]
-///
-///     # High rank indices (for each i, ..., j)
-///     ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]
-///
-/// Duplicate entries are handled correctly: if multiple `indices` reference
-/// the same location, their contributions add.
-///
-/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
-/// </div>
-///
-/// - Parameters:
-///   - resource: Should be from a `Variable` node.
-///   - indices: A tensor of indices into the first dimension of `ref`.
-///   - updates: A tensor of updated values to add to `ref`.
-@inlinable
-public static func resourceScatterAdd<
-    Dtype: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  resource: ResourceHandle,
-  indices: Tensor<Tindices>,
-  updates: Tensor<Dtype>
-) {
-  let op = TFE_Op("ResourceScatterAdd")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  op.execute()
-}
-
-/// Divides sparse updates into the variable referenced by `resource`.
-///
-/// This operation computes
-///
-///     # Scalar indices
-///     ref[indices, ...] /= updates[...]
-///
-///     # Vector indices (for each i)
-///     ref[indices[i], ...] /= updates[i, ...]
-///
-///     # High rank indices (for each i, ..., j)
-///     ref[indices[i, ..., j], ...] /= updates[i, ..., j, ...]
-///
-/// Duplicate entries are handled correctly: if multiple `indices` reference
-/// the same location, their contributions multiply.
-///
-/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
-/// </div>
-///
-/// - Parameters:
-///   - resource: Should be from a `Variable` node.
-///   - indices: A tensor of indices into the first dimension of `ref`.
-///   - updates: A tensor of updated values to add to `ref`.
-@inlinable
-public static func resourceScatterDiv<
-    Dtype: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  resource: ResourceHandle,
-  indices: Tensor<Tindices>,
-  updates: Tensor<Dtype>
-) {
-  let op = TFE_Op("ResourceScatterDiv")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  op.execute()
-}
-
-/// Reduces sparse updates into the variable referenced by `resource` using the `max` operation.
-///
-/// This operation computes
-///
-///     # Scalar indices
-///     ref[indices, ...] = max(ref[indices, ...], updates[...])
-///
-///     # Vector indices (for each i)
-///     ref[indices[i], ...] = max(ref[indices[i], ...], updates[i, ...])
-///
-///     # High rank indices (for each i, ..., j)
-///     ref[indices[i, ..., j], ...] = max(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
-///
-/// Duplicate entries are handled correctly: if multiple `indices` reference
-/// the same location, their contributions are combined.
-///
-/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
-/// </div>
-///
-/// - Parameters:
-///   - resource: Should be from a `Variable` node.
-///   - indices: A tensor of indices into the first dimension of `ref`.
-///   - updates: A tensor of updated values to add to `ref`.
-@inlinable
-public static func resourceScatterMax<
-    Dtype: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  resource: ResourceHandle,
-  indices: Tensor<Tindices>,
-  updates: Tensor<Dtype>
-) {
-  let op = TFE_Op("ResourceScatterMax")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  op.execute()
-}
-
-/// Reduces sparse updates into the variable referenced by `resource` using the `min` operation.
-///
-/// This operation computes
-///
-///     # Scalar indices
-///     ref[indices, ...] = min(ref[indices, ...], updates[...])
-///
-///     # Vector indices (for each i)
-///     ref[indices[i], ...] = min(ref[indices[i], ...], updates[i, ...])
-///
-///     # High rank indices (for each i, ..., j)
-///     ref[indices[i, ..., j], ...] = min(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
-///
-/// Duplicate entries are handled correctly: if multiple `indices` reference
-/// the same location, their contributions are combined.
-///
-/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
-/// </div>
-///
-/// - Parameters:
-///   - resource: Should be from a `Variable` node.
-///   - indices: A tensor of indices into the first dimension of `ref`.
-///   - updates: A tensor of updated values to add to `ref`.
-@inlinable
-public static func resourceScatterMin<
-    Dtype: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  resource: ResourceHandle,
-  indices: Tensor<Tindices>,
-  updates: Tensor<Dtype>
-) {
-  let op = TFE_Op("ResourceScatterMin")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  op.execute()
-}
-
-/// Multiplies sparse updates into the variable referenced by `resource`.
-///
-/// This operation computes
-///
-///     # Scalar indices
-///     ref[indices, ...] *= updates[...]
-///
-///     # Vector indices (for each i)
-///     ref[indices[i], ...] *= updates[i, ...]
-///
-///     # High rank indices (for each i, ..., j)
-///     ref[indices[i, ..., j], ...] *= updates[i, ..., j, ...]
-///
-/// Duplicate entries are handled correctly: if multiple `indices` reference
-/// the same location, their contributions multiply.
-///
-/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
-/// </div>
-///
-/// - Parameters:
-///   - resource: Should be from a `Variable` node.
-///   - indices: A tensor of indices into the first dimension of `ref`.
-///   - updates: A tensor of updated values to add to `ref`.
-@inlinable
-public static func resourceScatterMul<
-    Dtype: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  resource: ResourceHandle,
-  indices: Tensor<Tindices>,
-  updates: Tensor<Dtype>
-) {
-  let op = TFE_Op("ResourceScatterMul")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  op.execute()
-}
-
-/// Applies sparse addition to individual values or slices in a Variable.
-///
-/// `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-///
-/// `indices` must be integer tensor, containing indices into `ref`.
-/// It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
-///
-/// The innermost dimension of `indices` (with length `K`) corresponds to
-/// indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
-/// dimension of `ref`.
-///
-/// `updates` is `Tensor` of rank `Q-1+P-K` with shape:
-///
-/// ```
-/// [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
-/// ```
-///
-/// For example, say we want to add 4 scattered elements to a rank-1 tensor to
-/// 8 elements. In Python, that addition would look like this:
-///
-/// ```python
-/// ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8], use_resource=True)
-/// indices = tf.constant([[4], [3], [1], [7]])
-/// updates = tf.constant([9, 10, 11, 12])
-/// add = tf.scatter_nd_add(ref, indices, updates)
-/// with tf.Session() as sess:
-///   print sess.run(add)
-/// ```
-///
-/// The resulting update to ref would look like this:
-///
-///     [1, 13, 3, 14, 14, 6, 7, 20]
-///
-/// See `tf.scatter_nd` for more details about how to make updates to
-/// slices.
-///
-/// - Parameters:
-///   - ref: A resource handle. Must be from a VarHandleOp.
-///   - indices: A Tensor. Must be one of the following types: int32, int64.
-///     A tensor of indices into ref.
-///   - updates: A Tensor. Must have the same type as ref. A tensor of
-///     values to add to ref.
-///
-/// - Attr use_locking: An optional bool. Defaults to True. If True, the assignment will
-///   be protected by a lock; otherwise the behavior is undefined,
-///   but may exhibit less contention.
-@inlinable
-public static func resourceScatterNdAdd<
-    T: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  ref: ResourceHandle,
-  indices: Tensor<Tindices>,
-  updates: Tensor<T>,
-  useLocking: Bool = true
-) {
-  let op = TFE_Op("ResourceScatterNdAdd")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(ref)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  op.execute()
-}
-
-/// Applies sparse subtraction to individual values or slices in a Variable.
-///
-/// `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-///
-/// `indices` must be integer tensor, containing indices into `ref`.
-/// It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
-///
-/// The innermost dimension of `indices` (with length `K`) corresponds to
-/// indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
-/// dimension of `ref`.
-///
-/// `updates` is `Tensor` of rank `Q-1+P-K` with shape:
-///
-/// ```
-/// [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
-/// ```
-///
-/// For example, say we want to subtract 4 scattered elements from a rank-1 tensor
-/// with 8 elements. In Python, that subtraction would look like this:
-///
-/// ```python
-/// ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8], use_resource=True)
-/// indices = tf.constant([[4], [3], [1], [7]])
-/// updates = tf.constant([9, 10, 11, 12])
-/// sub = tf.scatter_nd_sub(ref, indices, updates)
-/// with tf.Session() as sess:
-///   print sess.run(sub)
-/// ```
-///
-/// The resulting update to ref would look like this:
-///
-///     [1, -9, 3, -6, -4, 6, 7, -4]
-///
-/// See `tf.scatter_nd` for more details about how to make updates to
-/// slices.
-///
-/// - Parameters:
-///   - ref: A resource handle. Must be from a VarHandleOp.
-///   - indices: A Tensor. Must be one of the following types: int32, int64.
-///     A tensor of indices into ref.
-///   - updates: A Tensor. Must have the same type as ref. A tensor of
-///     values to add to ref.
-///
-/// - Attr use_locking: An optional bool. Defaults to True. If True, the assignment will
-///   be protected by a lock; otherwise the behavior is undefined,
-///   but may exhibit less contention.
-@inlinable
-public static func resourceScatterNdSub<
-    T: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  ref: ResourceHandle,
-  indices: Tensor<Tindices>,
-  updates: Tensor<T>,
-  useLocking: Bool = true
-) {
-  let op = TFE_Op("ResourceScatterNdSub")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(ref)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  op.execute()
-}
-
-/// Applies sparse `updates` to individual values or slices within a given
-///
-/// variable according to `indices`.
-///
-/// `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-///
-/// `indices` must be integer tensor, containing indices into `ref`.
-/// It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
-///
-/// The innermost dimension of `indices` (with length `K`) corresponds to
-/// indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
-/// dimension of `ref`.
-///
-/// `updates` is `Tensor` of rank `Q-1+P-K` with shape:
-///
-/// ```
-/// [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
-/// ```
-///
-/// For example, say we want to update 4 scattered elements to a rank-1 tensor to
-/// 8 elements. In Python, that update would look like this:
-///
-/// ```python
-///     ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
-///     indices = tf.constant([[4], [3], [1] ,[7]])
-///     updates = tf.constant([9, 10, 11, 12])
-///     update = tf.scatter_nd_update(ref, indices, updates)
-///     with tf.Session() as sess:
-///       print sess.run(update)
-/// ```
-///
-/// The resulting update to ref would look like this:
-///
-///     [1, 11, 3, 10, 9, 6, 7, 12]
-///
-/// See `tf.scatter_nd` for more details about how to make updates to
-/// slices.
-///
-/// - Parameters:
-///   - ref: A resource handle. Must be from a VarHandleOp.
-///   - indices: A Tensor. Must be one of the following types: int32, int64.
-///     A tensor of indices into ref.
-///   - updates: A Tensor. Must have the same type as ref. A tensor of updated
-///     values to add to ref.
-///
-/// - Attr use_locking: An optional bool. Defaults to True. If True, the assignment will
-///   be protected by a lock; otherwise the behavior is undefined,
-///   but may exhibit less contention.
-@inlinable
-public static func resourceScatterNdUpdate<
-    T: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  ref: ResourceHandle,
-  indices: Tensor<Tindices>,
-  updates: Tensor<T>,
-  useLocking: Bool = true
-) {
-  let op = TFE_Op("ResourceScatterNdUpdate")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(ref)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  op.execute()
-}
-
-/// Subtracts sparse updates from the variable referenced by `resource`.
-///
-/// This operation computes
-///
-///     # Scalar indices
-///     ref[indices, ...] -= updates[...]
-///
-///     # Vector indices (for each i)
-///     ref[indices[i], ...] -= updates[i, ...]
-///
-///     # High rank indices (for each i, ..., j)
-///     ref[indices[i, ..., j], ...] -= updates[i, ..., j, ...]
-///
-/// Duplicate entries are handled correctly: if multiple `indices` reference
-/// the same location, their contributions add.
-///
-/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
-/// </div>
-///
-/// - Parameters:
-///   - resource: Should be from a `Variable` node.
-///   - indices: A tensor of indices into the first dimension of `ref`.
-///   - updates: A tensor of updated values to add to `ref`.
-@inlinable
-public static func resourceScatterSub<
-    Dtype: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  resource: ResourceHandle,
-  indices: Tensor<Tindices>,
-  updates: Tensor<Dtype>
-) {
-  let op = TFE_Op("ResourceScatterSub")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  op.execute()
-}
-
-/// Assigns sparse updates to the variable referenced by `resource`.
-///
-/// This operation computes
-///
-///     # Scalar indices
-///     ref[indices, ...] = updates[...]
-///
-///     # Vector indices (for each i)
-///     ref[indices[i], ...] = updates[i, ...]
-///
-///     # High rank indices (for each i, ..., j)
-///     ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]
-///
-/// - Parameters:
-///   - resource: Should be from a `Variable` node.
-///   - indices: A tensor of indices into the first dimension of `ref`.
-///   - updates: A tensor of updated values to add to `ref`.
-@inlinable
-public static func resourceScatterUpdate<
-    Dtype: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  resource: ResourceHandle,
-  indices: Tensor<Tindices>,
-  updates: Tensor<Dtype>
-) {
-  let op = TFE_Op("ResourceScatterUpdate")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  op.execute()
-}
-
-/// var: Should be from a Variable().
-///
-/// - Parameters:
-///   - accum: Should be from a Variable().
-///   - accum_update: : Should be from a Variable().
-///   - lr: Learning rate. Must be a scalar.
-///   - rho: Decay factor. Must be a scalar.
-///   - epsilon: Constant factor. Must be a scalar.
-///   - grad: The gradient.
-///   - indices: A vector of indices into the first dimension of var and accum.
-///
-/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
-///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable
-public static func resourceSparseApplyAdadelta<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  accumUpdate: ResourceHandle,
-  lr: Tensor<T>,
-  rho: Tensor<T>,
-  epsilon: Tensor<T>,
-  grad: Tensor<T>,
-  indices: Tensor<Tindices>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceSparseApplyAdadelta")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(accumUpdate)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(rho)
-  let _ = op.addInput(epsilon)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  op.execute()
-}
-
-/// Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
-///
-/// That is for rows we have grad for, we update var and accum as follows:
-/// accum += grad * grad
-/// var -= lr * grad * (1 / sqrt(accum))
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - lr: Learning rate. Must be a scalar.
-///   - grad: The gradient.
-///   - indices: A vector of indices into the first dimension of var and accum.
-///
-/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
-///   by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceSparseApplyAdagrad<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  lr: Tensor<T>,
-  grad: Tensor<T>,
-  indices: Tensor<Tindices>,
-  useLocking: Bool = false,
-  updateSlots: Bool = true
-) {
-  let op = TFE_Op("ResourceSparseApplyAdagrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  op.setAttr("update_slots", updateSlots)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  op.execute()
-}
-
-/// Update entries in '*var' and '*accum' according to the proximal adagrad scheme.
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - gradient_accumulator: Should be from a Variable().
-///   - gradient_squared_accumulator: Should be from a Variable().
-///   - grad: The gradient.
-///   - indices: A vector of indices into the first dimension of var and accum.
-///   - lr: Learning rate. Must be a scalar.
-///   - l1: L1 regularization. Must be a scalar.
-///   - l2: L2 regularization. Must be a scalar.
-///   - global_step: Training step number. Must be a scalar.
-///
-/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
-///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable
-public static func resourceSparseApplyAdagradDA<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  var_: ResourceHandle,
-  gradientAccumulator: ResourceHandle,
-  gradientSquaredAccumulator: ResourceHandle,
-  grad: Tensor<T>,
-  indices: Tensor<Tindices>,
-  lr: Tensor<T>,
-  l1: Tensor<T>,
-  l2: Tensor<T>,
-  globalStep: Tensor<Int64>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceSparseApplyAdagradDA")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(gradientAccumulator)
-  let _ = op.addInput(gradientSquaredAccumulator)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  let _ = op.addInput(globalStep)
-  op.execute()
-}
-
-/// Update '*var' according to the centered RMSProp algorithm.
-///
-/// The centered RMSProp algorithm uses an estimate of the centered second moment
-/// (i.e., the variance) for normalization, as opposed to regular RMSProp, which
-/// uses the (uncentered) second moment. This often helps with training, but is
-/// slightly more expensive in terms of computation and memory.
-///
-/// Note that in dense implementation of this algorithm, mg, ms, and mom will
-/// update even if the grad is zero, but in this sparse implementation, mg, ms,
-/// and mom will not update in iterations during which the grad is zero.
-///
-/// mean_square = decay * mean_square + (1-decay) * gradient ** 2
-/// mean_grad = decay * mean_grad + (1-decay) * gradient
-/// Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
-///
-/// ms <- rho * ms_{t-1} + (1-rho) * grad * grad
-/// mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
-/// var <- var - mom
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - mg: Should be from a Variable().
-///   - ms: Should be from a Variable().
-///   - mom: Should be from a Variable().
-///   - lr: Scaling factor. Must be a scalar.
-///   - rho: Decay rate. Must be a scalar.
-///   - epsilon: Ridge term. Must be a scalar.
-///   - grad: The gradient.
-///   - indices: A vector of indices into the first dimension of var, ms and mom.
-///
-/// - Attr use_locking: If `True`, updating of the var, mg, ms, and mom tensors is
-///   protected by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceSparseApplyCenteredRMSProp<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  var_: ResourceHandle,
-  mg: ResourceHandle,
-  ms: ResourceHandle,
-  mom: ResourceHandle,
-  lr: Tensor<T>,
-  rho: Tensor<T>,
-  momentum: Tensor<T>,
-  epsilon: Tensor<T>,
-  grad: Tensor<T>,
-  indices: Tensor<Tindices>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceSparseApplyCenteredRMSProp")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(mg)
-  let _ = op.addInput(ms)
-  let _ = op.addInput(mom)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(rho)
-  let _ = op.addInput(momentum)
-  let _ = op.addInput(epsilon)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  op.execute()
-}
-
-/// Update relevant entries in '*var' according to the Ftrl-proximal scheme.
-///
-/// That is for rows we have grad for, we update var, accum and linear as follows:
-/// accum_new = accum + grad * grad
-/// linear += grad + (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
-/// quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
-/// var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
-/// accum = accum_new
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - linear: Should be from a Variable().
-///   - grad: The gradient.
-///   - indices: A vector of indices into the first dimension of var and accum.
-///   - lr: Scaling factor. Must be a scalar.
-///   - l1: L1 regularization. Must be a scalar.
-///   - l2: L2 regularization. Must be a scalar.
-///   - lr_power: Scaling factor. Must be a scalar.
-///
-/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
-///   by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceSparseApplyFtrl<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  linear: ResourceHandle,
-  grad: Tensor<T>,
-  indices: Tensor<Tindices>,
-  lr: Tensor<T>,
-  l1: Tensor<T>,
-  l2: Tensor<T>,
-  lrPower: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceSparseApplyFtrl")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(linear)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  let _ = op.addInput(lrPower)
-  op.execute()
-}
-
-/// Update relevant entries in '*var' according to the Ftrl-proximal scheme.
-///
-/// That is for rows we have grad for, we update var, accum and linear as follows:
-/// grad_with_shrinkage = grad + 2 * l2_shrinkage * var
-/// accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
-/// linear += grad_with_shrinkage +
-///     (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
-/// quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
-/// var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
-/// accum = accum_new
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - linear: Should be from a Variable().
-///   - grad: The gradient.
-///   - indices: A vector of indices into the first dimension of var and accum.
-///   - lr: Scaling factor. Must be a scalar.
-///   - l1: L1 regularization. Must be a scalar.
-///   - l2: L2 shrinkage regulariation. Must be a scalar.
-///   - lr_power: Scaling factor. Must be a scalar.
-///
-/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
-///   by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceSparseApplyFtrlV2<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  linear: ResourceHandle,
-  grad: Tensor<T>,
-  indices: Tensor<Tindices>,
-  lr: Tensor<T>,
-  l1: Tensor<T>,
-  l2: Tensor<T>,
-  l2Shrinkage: Tensor<T>,
-  lrPower: Tensor<T>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceSparseApplyFtrlV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(linear)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  let _ = op.addInput(l2Shrinkage)
-  let _ = op.addInput(lrPower)
-  op.execute()
-}
-
-/// Update relevant entries in '*var' and '*accum' according to the momentum scheme.
-///
-/// Set use_nesterov = True if you want to use Nesterov momentum.
-///
-/// That is for rows we have grad for, we update var and accum as follows:
-///
-/// accum = accum * momentum - lr * grad
-/// var += accum
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - lr: Learning rate. Must be a scalar.
-///   - grad: The gradient.
-///   - indices: A vector of indices into the first dimension of var and accum.
-///   - momentum: Momentum. Must be a scalar.
-///
-/// - Attrs:
-///   - use_locking: If `True`, updating of the var and accum tensors will be protected
-///     by a lock; otherwise the behavior is undefined, but may exhibit less
-///     contention.
-///   - use_nesterov: If `True`, the tensor passed to compute grad will be
-///     var + momentum * accum, so in the end, the var you get is actually
-///     var + momentum * accum.
-@inlinable
-public static func resourceSparseApplyKerasMomentum<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  lr: Tensor<T>,
-  grad: Tensor<T>,
-  indices: Tensor<Tindices>,
-  momentum: Tensor<T>,
-  useLocking: Bool = false,
-  useNesterov: Bool = false
-) {
-  let op = TFE_Op("ResourceSparseApplyKerasMomentum")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  op.setAttr("use_nesterov", useNesterov)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(momentum)
-  op.execute()
-}
-
-/// Update relevant entries in '*var' and '*accum' according to the momentum scheme.
-///
-/// Set use_nesterov = True if you want to use Nesterov momentum.
-///
-/// That is for rows we have grad for, we update var and accum as follows:
-///
-/// accum = accum * momentum + grad
-/// var -= lr * accum
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - lr: Learning rate. Must be a scalar.
-///   - grad: The gradient.
-///   - indices: A vector of indices into the first dimension of var and accum.
-///   - momentum: Momentum. Must be a scalar.
-///
-/// - Attrs:
-///   - use_locking: If `True`, updating of the var and accum tensors will be protected
-///     by a lock; otherwise the behavior is undefined, but may exhibit less
-///     contention.
-///   - use_nesterov: If `True`, the tensor passed to compute grad will be
-///     var - lr * momentum * accum, so in the end, the var you get is actually
-///     var - lr * momentum * accum.
-@inlinable
-public static func resourceSparseApplyMomentum<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  lr: Tensor<T>,
-  grad: Tensor<T>,
-  indices: Tensor<Tindices>,
-  momentum: Tensor<T>,
-  useLocking: Bool = false,
-  useNesterov: Bool = false
-) {
-  let op = TFE_Op("ResourceSparseApplyMomentum")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  op.setAttr("use_nesterov", useNesterov)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(momentum)
-  op.execute()
-}
-
-/// Sparse update entries in '*var' and '*accum' according to FOBOS algorithm.
-///
-/// That is for rows we have grad for, we update var and accum as follows:
-/// accum += grad * grad
-/// prox_v = var
-/// prox_v -= lr * grad * (1 / sqrt(accum))
-/// var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - accum: Should be from a Variable().
-///   - lr: Learning rate. Must be a scalar.
-///   - l1: L1 regularization. Must be a scalar.
-///   - l2: L2 regularization. Must be a scalar.
-///   - grad: The gradient.
-///   - indices: A vector of indices into the first dimension of var and accum.
-///
-/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
-///   a lock; otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable
-public static func resourceSparseApplyProximalAdagrad<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  var_: ResourceHandle,
-  accum: ResourceHandle,
-  lr: Tensor<T>,
-  l1: Tensor<T>,
-  l2: Tensor<T>,
-  grad: Tensor<T>,
-  indices: Tensor<Tindices>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceSparseApplyProximalAdagrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(accum)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  op.execute()
-}
-
-/// Sparse update '*var' as FOBOS algorithm with fixed learning rate.
-///
-/// That is for rows we have grad for, we update var as follows:
-/// prox_v = var - alpha * grad
-/// var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - alpha: Scaling factor. Must be a scalar.
-///   - l1: L1 regularization. Must be a scalar.
-///   - l2: L2 regularization. Must be a scalar.
-///   - grad: The gradient.
-///   - indices: A vector of indices into the first dimension of var and accum.
-///
-/// - Attr use_locking: If True, the subtraction will be protected by a lock;
-///   otherwise the behavior is undefined, but may exhibit less contention.
-@inlinable
-public static func resourceSparseApplyProximalGradientDescent<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  var_: ResourceHandle,
-  alpha: Tensor<T>,
-  l1: Tensor<T>,
-  l2: Tensor<T>,
-  grad: Tensor<T>,
-  indices: Tensor<Tindices>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceSparseApplyProximalGradientDescent")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(alpha)
-  let _ = op.addInput(l1)
-  let _ = op.addInput(l2)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  op.execute()
-}
-
-/// Update '*var' according to the RMSProp algorithm.
-///
-/// Note that in dense implementation of this algorithm, ms and mom will
-/// update even if the grad is zero, but in this sparse implementation, ms
-/// and mom will not update in iterations during which the grad is zero.
-///
-/// mean_square = decay * mean_square + (1-decay) * gradient ** 2
-/// Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
-///
-/// ms <- rho * ms_{t-1} + (1-rho) * grad * grad
-/// mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
-/// var <- var - mom
-///
-/// - Parameters:
-///   - var: Should be from a Variable().
-///   - ms: Should be from a Variable().
-///   - mom: Should be from a Variable().
-///   - lr: Scaling factor. Must be a scalar.
-///   - rho: Decay rate. Must be a scalar.
-///   - epsilon: Ridge term. Must be a scalar.
-///   - grad: The gradient.
-///   - indices: A vector of indices into the first dimension of var, ms and mom.
-///
-/// - Attr use_locking: If `True`, updating of the var, ms, and mom tensors is protected
-///   by a lock; otherwise the behavior is undefined, but may exhibit less
-///   contention.
-@inlinable
-public static func resourceSparseApplyRMSProp<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  var_: ResourceHandle,
-  ms: ResourceHandle,
-  mom: ResourceHandle,
-  lr: Tensor<T>,
-  rho: Tensor<T>,
-  momentum: Tensor<T>,
-  epsilon: Tensor<T>,
-  grad: Tensor<T>,
-  indices: Tensor<Tindices>,
-  useLocking: Bool = false
-) {
-  let op = TFE_Op("ResourceSparseApplyRMSProp")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("use_locking", useLocking)
-  let _ = op.addInput(var_)
-  let _ = op.addInput(ms)
-  let _ = op.addInput(mom)
-  let _ = op.addInput(lr)
-  let _ = op.addInput(rho)
-  let _ = op.addInput(momentum)
-  let _ = op.addInput(epsilon)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  op.execute()
-}
-
-/// Assign `value` to the sliced l-value reference of `ref`.
-///
-/// The values of `value` are assigned to the positions in the variable
-/// `ref` that are selected by the slice parameters. The slice parameters
-/// `begin, `end`, `strides`, etc. work exactly as in `StridedSlice`.
-///
-/// NOTE this op currently does not support broadcasting and so `value`'s
-/// shape must be exactly the shape produced by the slice of `ref`.
-@inlinable
-public static func resourceStridedSliceAssign<
-    T: TensorFlowScalar,
-    Index: BinaryInteger & TensorFlowScalar
->(
-  ref: ResourceHandle,
-  begin: Tensor<Index>,
-  end: Tensor<Index>,
-  strides: Tensor<Index>,
-  value: Tensor<T>,
-  beginMask: Int64 = 0,
-  endMask: Int64 = 0,
-  ellipsisMask: Int64 = 0,
-  newAxisMask: Int64 = 0,
-  shrinkAxisMask: Int64 = 0
-) {
-  let op = TFE_Op("ResourceStridedSliceAssign")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Index", Index.tensorFlowDataType)
-  op.setAttr("begin_mask", beginMask)
-  op.setAttr("end_mask", endMask)
-  op.setAttr("ellipsis_mask", ellipsisMask)
-  op.setAttr("new_axis_mask", newAxisMask)
-  op.setAttr("shrink_axis_mask", shrinkAxisMask)
-  let _ = op.addInput(ref)
-  let _ = op.addInput(begin)
-  let _ = op.addInput(end)
-  let _ = op.addInput(strides)
-  let _ = op.addInput(value)
-  op.execute()
-}
-
-@inlinable
-public static func resourceUsingOp(
-  resource: ResourceHandle
-) {
-  let op = TFE_Op("ResourceUsingOp")
-  let _ = op.addInput(resource)
-  op.execute()
-}
-
-/// Restores a tensor from checkpoint files.
-///
-/// Reads a tensor stored in one or several files. If there are several files (for
-/// instance because a tensor was saved as slices), `file_pattern` may contain
-/// wildcard symbols (`*` and `?`) in the filename portion only, not in the
-/// directory portion.
-///
-/// If a `file_pattern` matches several files, `preferred_shard` can be used to hint
-/// in which file the requested tensor is likely to be found. This op will first
-/// open the file at index `preferred_shard` in the list of matching files and try
-/// to restore tensors from that file.  Only if some tensors or tensor slices are
-/// not found in that first file, then the Op opens all the files. Setting
-/// `preferred_shard` to match the value passed as the `shard` input
-/// of a matching `Save` Op may speed up Restore.  This attribute only affects
-/// performance, not correctness.  The default value -1 means files are processed in
-/// order.
-///
-/// See also `RestoreSlice`.
-///
-/// - Parameters:
-///   - file_pattern: Must have a single element. The pattern of the files from
-///     which we read the tensor.
-///   - tensor_name: Must have a single element. The name of the tensor to be
-///     restored.
-///
-/// - Attrs:
-///   - dt: The type of the tensor to be restored.
-///   - preferred_shard: Index of file to open first if multiple files match
-///     `file_pattern`.
-///
-/// - Output tensor: The restored tensor.
-@inlinable
-public static func restore<Dt: TensorFlowScalar>(
-  filePattern: StringTensor,
-  tensorName: StringTensor,
-  preferredShard: Int64 = -1
-) -> Tensor<Dt> {
-  let op = TFE_Op("Restore")
-  op.setAttr("dt", Dt.tensorFlowDataType)
-  op.setAttr("preferred_shard", preferredShard)
-  let _ = op.addInput(filePattern)
-  let _ = op.addInput(tensorName)
-  return op.execute(Int(1))
-}
-
-/// Restores a tensor from checkpoint files.
-///
-/// This is like `Restore` except that restored tensor can be listed as filling
-/// only a slice of a larger tensor.  `shape_and_slice` specifies the shape of the
-/// larger tensor and the slice that the restored tensor covers.
-///
-/// The `shape_and_slice` input has the same format as the
-/// elements of the `shapes_and_slices` input of the `SaveSlices` op.
-///
-/// - Parameters:
-///   - file_pattern: Must have a single element. The pattern of the files from
-///     which we read the tensor.
-///   - tensor_name: Must have a single element. The name of the tensor to be
-///     restored.
-///   - shape_and_slice: Scalar. The shapes and slice specifications to use when
-///     restoring a tensors.
-///
-/// - Attrs:
-///   - dt: The type of the tensor to be restored.
-///   - preferred_shard: Index of file to open first if multiple files match
-///     `file_pattern`. See the documentation for `Restore`.
-///
-/// - Output tensor: The restored tensor.
-@inlinable
-public static func restoreSlice<Dt: TensorFlowScalar>(
-  filePattern: StringTensor,
-  tensorName: StringTensor,
-  shapeAndSlice: StringTensor,
-  preferredShard: Int64 = -1
-) -> Tensor<Dt> {
-  let op = TFE_Op("RestoreSlice")
-  op.setAttr("dt", Dt.tensorFlowDataType)
-  op.setAttr("preferred_shard", preferredShard)
-  let _ = op.addInput(filePattern)
-  let _ = op.addInput(tensorName)
-  let _ = op.addInput(shapeAndSlice)
-  return op.execute(Int(1))
-}
-
-/// Restores tensors from a V2 checkpoint.
-///
-/// For backward compatibility with the V1 format, this Op currently allows
-/// restoring from a V1 checkpoint as well:
-///   - This Op first attempts to find the V2 index file pointed to by "prefix", and
-///     if found proceed to read it as a V2 checkpoint;
-///   - Otherwise the V1 read path is invoked.
-/// Relying on this behavior is not recommended, as the ability to fall back to read
-/// V1 might be deprecated and eventually removed.
-///
-/// By default, restores the named tensors in full.  If the caller wishes to restore
-/// specific slices of stored tensors, "shape_and_slices" should be non-empty
-/// strings and correspondingly well-formed.
-///
-/// Callers must ensure all the named tensors are indeed stored in the checkpoint.
-///
-/// - Parameters:
-///   - prefix: Must have a single element.  The prefix of a V2 checkpoint.
-///   - tensor_names: shape {N}.  The names of the tensors to be restored.
-///   - shape_and_slices: shape {N}.  The slice specs of the tensors to be restored.
-///     Empty strings indicate that they are non-partitioned tensors.
-///
-/// - Attr dtypes: shape {N}.  The list of expected dtype for the tensors.  Must match
-///   those stored in the checkpoint.
-///
-/// - Output tensors: shape {N}.  The restored tensors, whose shapes are read from the
-///   checkpoint directly.
-@inlinable
-public static func restoreV2<Dtypes: TensorGroup>(
-  prefix: StringTensor,
-  tensorNames: StringTensor,
-  shapeAndSlices: StringTensor
-) -> Dtypes {
-  let op = TFE_Op("RestoreV2")
-  op.setAttr("dtypes", Dtypes._typeList)
-  let _ = op.addInput(prefix)
-  let _ = op.addInput(tensorNames)
-  let _ = op.addInput(shapeAndSlices)
-  return op.execute(Int(Dtypes._typeList.count))
-}
-
-@inlinable
-public static func restrict<T: TensorFlowScalar>(
-  _ a: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Restrict")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func restrict(
-  _ a: StringTensor
-) -> StringTensor {
-  let op = TFE_Op("Restrict")
-  op.setAttr("T", TensorDataType(TF_STRING))
-  let _ = op.addInput(a)
-  return op.execute(Int(1))
-}
-
-/// Retrieve ADAM embedding parameters.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the ADAM optimization algorithm.
-///   - momenta: Parameter momenta updated by the ADAM optimization algorithm.
-///   - velocities: Parameter velocities updated by the ADAM optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingADAMParameters(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, momenta: Tensor<Float>, velocities: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingADAMParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Retrieve ADAM embedding parameters with debug support.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the ADAM optimization algorithm.
-///   - momenta: Parameter momenta updated by the ADAM optimization algorithm.
-///   - velocities: Parameter velocities updated by the ADAM optimization algorithm.
-///   - gradient_accumulators: Parameter gradient_accumulators updated by the ADAM optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingADAMParametersGradAccumDebug(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, momenta: Tensor<Float>, velocities: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingADAMParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Retrieve Adadelta embedding parameters.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the Adadelta optimization algorithm.
-///   - accumulators: Parameter accumulators updated by the Adadelta optimization algorithm.
-///   - updates: Parameter updates updated by the Adadelta optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingAdadeltaParameters(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, updates: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingAdadeltaParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Retrieve Adadelta embedding parameters with debug support.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the Adadelta optimization algorithm.
-///   - accumulators: Parameter accumulators updated by the Adadelta optimization algorithm.
-///   - updates: Parameter updates updated by the Adadelta optimization algorithm.
-///   - gradient_accumulators: Parameter gradient_accumulators updated by the Adadelta optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingAdadeltaParametersGradAccumDebug(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, updates: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Retrieve Adagrad embedding parameters.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the Adagrad optimization algorithm.
-///   - accumulators: Parameter accumulators updated by the Adagrad optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingAdagradParameters(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingAdagradParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Retrieve Adagrad embedding parameters with debug support.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the Adagrad optimization algorithm.
-///   - accumulators: Parameter accumulators updated by the Adagrad optimization algorithm.
-///   - gradient_accumulators: Parameter gradient_accumulators updated by the Adagrad optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingAdagradParametersGradAccumDebug(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingAdagradParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Retrieve centered RMSProp embedding parameters.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the centered RMSProp optimization algorithm.
-///   - ms: Parameter ms updated by the centered RMSProp optimization algorithm.
-///   - mom: Parameter mom updated by the centered RMSProp optimization algorithm.
-///   - mg: Parameter mg updated by the centered RMSProp optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingCenteredRMSPropParameters(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, ms: Tensor<Float>, mom: Tensor<Float>, mg: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingCenteredRMSPropParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Retrieve FTRL embedding parameters.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the FTRL optimization algorithm.
-///   - accumulators: Parameter accumulators updated by the FTRL optimization algorithm.
-///   - linears: Parameter linears updated by the FTRL optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingFTRLParameters(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, linears: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingFTRLParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Retrieve FTRL embedding parameters with debug support.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the FTRL optimization algorithm.
-///   - accumulators: Parameter accumulators updated by the FTRL optimization algorithm.
-///   - linears: Parameter linears updated by the FTRL optimization algorithm.
-///   - gradient_accumulators: Parameter gradient_accumulators updated by the FTRL optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingFTRLParametersGradAccumDebug(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, linears: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingFTRLParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Retrieve MDL Adagrad Light embedding parameters.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the MDL Adagrad Light optimization algorithm.
-///   - accumulators: Parameter accumulators updated by the MDL Adagrad Light optimization algorithm.
-///   - weights: Parameter weights updated by the MDL Adagrad Light optimization algorithm.
-///   - benefits: Parameter benefits updated by the MDL Adagrad Light optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingMDLAdagradLightParameters(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, weights: Tensor<Float>, benefits: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingMDLAdagradLightParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Retrieve Momentum embedding parameters.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the Momentum optimization algorithm.
-///   - momenta: Parameter momenta updated by the Momentum optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingMomentumParameters(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, momenta: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingMomentumParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Retrieve Momentum embedding parameters with debug support.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the Momentum optimization algorithm.
-///   - momenta: Parameter momenta updated by the Momentum optimization algorithm.
-///   - gradient_accumulators: Parameter gradient_accumulators updated by the Momentum optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingMomentumParametersGradAccumDebug(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, momenta: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingMomentumParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Retrieve proximal Adagrad embedding parameters.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the proximal Adagrad optimization algorithm.
-///   - accumulators: Parameter accumulators updated by the proximal Adagrad optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingProximalAdagradParameters(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingProximalAdagradParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Retrieve proximal Adagrad embedding parameters with debug support.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the proximal Adagrad optimization algorithm.
-///   - accumulators: Parameter accumulators updated by the proximal Adagrad optimization algorithm.
-///   - gradient_accumulators: Parameter gradient_accumulators updated by the proximal Adagrad optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Retrieve RMSProp embedding parameters.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the RMSProp optimization algorithm.
-///   - ms: Parameter ms updated by the RMSProp optimization algorithm.
-///   - mom: Parameter mom updated by the RMSProp optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingRMSPropParameters(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, ms: Tensor<Float>, mom: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingRMSPropParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Retrieve RMSProp embedding parameters with debug support.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Outputs:
-///   - parameters: Parameter parameters updated by the RMSProp optimization algorithm.
-///   - ms: Parameter ms updated by the RMSProp optimization algorithm.
-///   - mom: Parameter mom updated by the RMSProp optimization algorithm.
-///   - gradient_accumulators: Parameter gradient_accumulators updated by the RMSProp optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingRMSPropParametersGradAccumDebug(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> (parameters: Tensor<Float>, ms: Tensor<Float>, mom: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
-  let op = TFE_Op("RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Retrieve SGD embedding parameters.
-///
-/// An op that retrieves optimization parameters from embedding to host
-/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
-/// the correct embedding table configuration. For example, this op is
-/// used to retrieve updated parameters before saving a checkpoint.
-///
-/// - Output parameters: Parameter parameters updated by the stochastic gradient descent optimization algorithm.
-@inlinable
-public static func retrieveTPUEmbeddingStochasticGradientDescentParameters(
-  tableId: Int64 = -1,
-  tableName: String,
-  numShards: Int64,
-  shardId: Int64
-) -> Tensor<Float> {
-  let op = TFE_Op("RetrieveTPUEmbeddingStochasticGradientDescentParameters")
-  op.setAttr("table_id", tableId)
-  op.setAttr("table_name", tableName)
-  op.setAttr("num_shards", numShards)
-  op.setAttr("shard_id", shardId)
-  return op.execute(Int(1))
-}
-
-/// Reverses specific dimensions of a tensor.
-///
-/// Given a `tensor`, and a `bool` tensor `dims` representing the dimensions
-/// of `tensor`, this operation reverses each dimension i of `tensor` where
-/// `dims[i]` is `True`.
-///
-/// `tensor` can have up to 8 dimensions. The number of dimensions
-/// of `tensor` must equal the number of elements in `dims`. In other words:
-///
-/// `rank(tensor) = size(dims)`
-///
-/// For example:
-///
-/// ```
-/// # tensor 't' is [[[[ 0,  1,  2,  3],
-/// #                  [ 4,  5,  6,  7],
-/// #                  [ 8,  9, 10, 11]],
-/// #                 [[12, 13, 14, 15],
-/// #                  [16, 17, 18, 19],
-/// #                  [20, 21, 22, 23]]]]
-/// # tensor 't' shape is [1, 2, 3, 4]
-///
-/// # 'dims' is [False, False, False, True]
-/// reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
-///                         [ 7,  6,  5,  4],
-///                         [ 11, 10, 9, 8]],
-///                        [[15, 14, 13, 12],
-///                         [19, 18, 17, 16],
-///                         [23, 22, 21, 20]]]]
-///
-/// # 'dims' is [False, True, False, False]
-/// reverse(t, dims) ==> [[[[12, 13, 14, 15],
-///                         [16, 17, 18, 19],
-///                         [20, 21, 22, 23]
-///                        [[ 0,  1,  2,  3],
-///                         [ 4,  5,  6,  7],
-///                         [ 8,  9, 10, 11]]]]
-///
-/// # 'dims' is [False, False, True, False]
-/// reverse(t, dims) ==> [[[[8, 9, 10, 11],
-///                         [4, 5, 6, 7],
-///                         [0, 1, 2, 3]]
-///                        [[20, 21, 22, 23],
-///                         [16, 17, 18, 19],
-///                         [12, 13, 14, 15]]]]
-/// ```
-///
-/// - Parameters:
-///   - tensor: Up to 8-D.
-///   - dims: 1-D. The dimensions to reverse.
-///
-/// - Output output: The same shape as `tensor`.
-@inlinable
-public static func reverse<T: TensorFlowScalar>(
-  _ tensor: Tensor<T>,
-  dims: Tensor<Bool>
-) -> Tensor<T> {
-  let op = TFE_Op("Reverse")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(dims)
-  return op.execute(Int(1))
-}
-
-/// Reverses specific dimensions of a tensor.
-///
-/// Given a `tensor`, and a `bool` tensor `dims` representing the dimensions
-/// of `tensor`, this operation reverses each dimension i of `tensor` where
-/// `dims[i]` is `True`.
-///
-/// `tensor` can have up to 8 dimensions. The number of dimensions
-/// of `tensor` must equal the number of elements in `dims`. In other words:
-///
-/// `rank(tensor) = size(dims)`
-///
-/// For example:
-///
-/// ```
-/// # tensor 't' is [[[[ 0,  1,  2,  3],
-/// #                  [ 4,  5,  6,  7],
-/// #                  [ 8,  9, 10, 11]],
-/// #                 [[12, 13, 14, 15],
-/// #                  [16, 17, 18, 19],
-/// #                  [20, 21, 22, 23]]]]
-/// # tensor 't' shape is [1, 2, 3, 4]
-///
-/// # 'dims' is [False, False, False, True]
-/// reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
-///                         [ 7,  6,  5,  4],
-///                         [ 11, 10, 9, 8]],
-///                        [[15, 14, 13, 12],
-///                         [19, 18, 17, 16],
-///                         [23, 22, 21, 20]]]]
-///
-/// # 'dims' is [False, True, False, False]
-/// reverse(t, dims) ==> [[[[12, 13, 14, 15],
-///                         [16, 17, 18, 19],
-///                         [20, 21, 22, 23]
-///                        [[ 0,  1,  2,  3],
-///                         [ 4,  5,  6,  7],
-///                         [ 8,  9, 10, 11]]]]
-///
-/// # 'dims' is [False, False, True, False]
-/// reverse(t, dims) ==> [[[[8, 9, 10, 11],
-///                         [4, 5, 6, 7],
-///                         [0, 1, 2, 3]]
-///                        [[20, 21, 22, 23],
-///                         [16, 17, 18, 19],
-///                         [12, 13, 14, 15]]]]
-/// ```
-///
-/// - Parameters:
-///   - tensor: Up to 8-D.
-///   - dims: 1-D. The dimensions to reverse.
-///
-/// - Output output: The same shape as `tensor`.
-@inlinable
-public static func reverse(
-  _ tensor: StringTensor,
-  dims: Tensor<Bool>
-) -> StringTensor {
-  let op = TFE_Op("Reverse")
-  op.setAttr("T", TensorDataType(TF_STRING))
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(dims)
-  return op.execute(Int(1))
-}
-
-/// Reverses variable length slices.
-///
-/// This op first slices `input` along the dimension `batch_dim`, and for each
-/// slice `i`, reverses the first `seq_lengths[i]` elements along
-/// the dimension `seq_dim`.
-///
-/// The elements of `seq_lengths` must obey `seq_lengths[i] <= input.dims[seq_dim]`,
-/// and `seq_lengths` must be a vector of length `input.dims[batch_dim]`.
-///
-/// The output slice `i` along dimension `batch_dim` is then given by input
-/// slice `i`, with the first `seq_lengths[i]` slices along dimension
-/// `seq_dim` reversed.
-///
-/// For example:
-///
-/// ```
-/// # Given this:
-/// batch_dim = 0
-/// seq_dim = 1
-/// input.dims = (4, 8, ...)
-/// seq_lengths = [7, 2, 3, 5]
-///
-/// # then slices of input are reversed on seq_dim, but only up to seq_lengths:
-/// output[0, 0:7, :, ...] = input[0, 7:0:-1, :, ...]
-/// output[1, 0:2, :, ...] = input[1, 2:0:-1, :, ...]
-/// output[2, 0:3, :, ...] = input[2, 3:0:-1, :, ...]
-/// output[3, 0:5, :, ...] = input[3, 5:0:-1, :, ...]
-///
-/// # while entries past seq_lens are copied through:
-/// output[0, 7:, :, ...] = input[0, 7:, :, ...]
-/// output[1, 2:, :, ...] = input[1, 2:, :, ...]
-/// output[2, 3:, :, ...] = input[2, 3:, :, ...]
-/// output[3, 2:, :, ...] = input[3, 2:, :, ...]
-/// ```
-///
-/// In contrast, if:
-///
-/// ```
-/// # Given this:
-/// batch_dim = 2
-/// seq_dim = 0
-/// input.dims = (8, ?, 4, ...)
-/// seq_lengths = [7, 2, 3, 5]
-///
-/// # then slices of input are reversed on seq_dim, but only up to seq_lengths:
-/// output[0:7, :, 0, :, ...] = input[7:0:-1, :, 0, :, ...]
-/// output[0:2, :, 1, :, ...] = input[2:0:-1, :, 1, :, ...]
-/// output[0:3, :, 2, :, ...] = input[3:0:-1, :, 2, :, ...]
-/// output[0:5, :, 3, :, ...] = input[5:0:-1, :, 3, :, ...]
-///
-/// # while entries past seq_lens are copied through:
-/// output[7:, :, 0, :, ...] = input[7:, :, 0, :, ...]
-/// output[2:, :, 1, :, ...] = input[2:, :, 1, :, ...]
-/// output[3:, :, 2, :, ...] = input[3:, :, 2, :, ...]
-/// output[2:, :, 3, :, ...] = input[2:, :, 3, :, ...]
-/// ```
-///
-/// - Parameters:
-///   - input: The input to reverse.
-///   - seq_lengths: 1-D with length `input.dims(batch_dim)` and
-///     `max(seq_lengths) <= input.dims(seq_dim)`
-///
-/// - Attrs:
-///   - seq_dim: The dimension which is partially reversed.
-///   - batch_dim: The dimension along which reversal is performed.
-///
-/// - Output output: The partially reversed input. It has the same shape as `input`.
-@inlinable
-public static func reverseSequence<
-    T: TensorFlowScalar,
-    Tlen: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  seqLengths: Tensor<Tlen>,
-  seqDim: Int64,
-  batchDim: Int64 = 0
-) -> Tensor<T> {
-  let op = TFE_Op("ReverseSequence")
-  op.setAttr("seq_dim", seqDim)
-  op.setAttr("batch_dim", batchDim)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tlen", Tlen.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(seqLengths)
-  return op.execute(Int(1))
-}
-
-/// Reverses specific dimensions of a tensor.
-///
-/// NOTE `tf.reverse` has now changed behavior in preparation for 1.0.
-/// `tf.reverse_v2` is currently an alias that will be deprecated before TF 1.0.
-///
-/// Given a `tensor`, and a `int32` tensor `axis` representing the set of
-/// dimensions of `tensor` to reverse. This operation reverses each dimension
-/// `i` for which there exists `j` s.t. `axis[j] == i`.
-///
-/// `tensor` can have up to 8 dimensions. The number of dimensions specified
-/// in `axis` may be 0 or more entries. If an index is specified more than
-/// once, a InvalidArgument error is raised.
-///
-/// For example:
-///
-/// ```
-/// # tensor 't' is [[[[ 0,  1,  2,  3],
-/// #                  [ 4,  5,  6,  7],
-/// #                  [ 8,  9, 10, 11]],
-/// #                 [[12, 13, 14, 15],
-/// #                  [16, 17, 18, 19],
-/// #                  [20, 21, 22, 23]]]]
-/// # tensor 't' shape is [1, 2, 3, 4]
-///
-/// # 'dims' is [3] or 'dims' is [-1]
-/// reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
-///                         [ 7,  6,  5,  4],
-///                         [ 11, 10, 9, 8]],
-///                        [[15, 14, 13, 12],
-///                         [19, 18, 17, 16],
-///                         [23, 22, 21, 20]]]]
-///
-/// # 'dims' is '[1]' (or 'dims' is '[-3]')
-/// reverse(t, dims) ==> [[[[12, 13, 14, 15],
-///                         [16, 17, 18, 19],
-///                         [20, 21, 22, 23]
-///                        [[ 0,  1,  2,  3],
-///                         [ 4,  5,  6,  7],
-///                         [ 8,  9, 10, 11]]]]
-///
-/// # 'dims' is '[2]' (or 'dims' is '[-2]')
-/// reverse(t, dims) ==> [[[[8, 9, 10, 11],
-///                         [4, 5, 6, 7],
-///                         [0, 1, 2, 3]]
-///                        [[20, 21, 22, 23],
-///                         [16, 17, 18, 19],
-///                         [12, 13, 14, 15]]]]
-/// ```
-///
-/// - Parameters:
-///   - tensor: Up to 8-D.
-///   - axis: 1-D. The indices of the dimensions to reverse. Must be in the range
-///     `[-rank(tensor), rank(tensor))`.
-///
-/// - Output output: The same shape as `tensor`.
-@inlinable
-public static func reverseV2<
-    Tidx: BinaryInteger & TensorFlowScalar,
-    T: TensorFlowScalar
->(
-  _ tensor: Tensor<T>,
-  axis: Tensor<Tidx>
-) -> Tensor<T> {
-  let op = TFE_Op("ReverseV2")
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(axis)
-  return op.execute(Int(1))
-}
-
-/// Reverses specific dimensions of a tensor.
-///
-/// NOTE `tf.reverse` has now changed behavior in preparation for 1.0.
-/// `tf.reverse_v2` is currently an alias that will be deprecated before TF 1.0.
-///
-/// Given a `tensor`, and a `int32` tensor `axis` representing the set of
-/// dimensions of `tensor` to reverse. This operation reverses each dimension
-/// `i` for which there exists `j` s.t. `axis[j] == i`.
-///
-/// `tensor` can have up to 8 dimensions. The number of dimensions specified
-/// in `axis` may be 0 or more entries. If an index is specified more than
-/// once, a InvalidArgument error is raised.
-///
-/// For example:
-///
-/// ```
-/// # tensor 't' is [[[[ 0,  1,  2,  3],
-/// #                  [ 4,  5,  6,  7],
-/// #                  [ 8,  9, 10, 11]],
-/// #                 [[12, 13, 14, 15],
-/// #                  [16, 17, 18, 19],
-/// #                  [20, 21, 22, 23]]]]
-/// # tensor 't' shape is [1, 2, 3, 4]
-///
-/// # 'dims' is [3] or 'dims' is [-1]
-/// reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
-///                         [ 7,  6,  5,  4],
-///                         [ 11, 10, 9, 8]],
-///                        [[15, 14, 13, 12],
-///                         [19, 18, 17, 16],
-///                         [23, 22, 21, 20]]]]
-///
-/// # 'dims' is '[1]' (or 'dims' is '[-3]')
-/// reverse(t, dims) ==> [[[[12, 13, 14, 15],
-///                         [16, 17, 18, 19],
-///                         [20, 21, 22, 23]
-///                        [[ 0,  1,  2,  3],
-///                         [ 4,  5,  6,  7],
-///                         [ 8,  9, 10, 11]]]]
-///
-/// # 'dims' is '[2]' (or 'dims' is '[-2]')
-/// reverse(t, dims) ==> [[[[8, 9, 10, 11],
-///                         [4, 5, 6, 7],
-///                         [0, 1, 2, 3]]
-///                        [[20, 21, 22, 23],
-///                         [16, 17, 18, 19],
-///                         [12, 13, 14, 15]]]]
-/// ```
-///
-/// - Parameters:
-///   - tensor: Up to 8-D.
-///   - axis: 1-D. The indices of the dimensions to reverse. Must be in the range
-///     `[-rank(tensor), rank(tensor))`.
-///
-/// - Output output: The same shape as `tensor`.
-@inlinable
-public static func reverseV2<Tidx: BinaryInteger & TensorFlowScalar>(
-  _ tensor: StringTensor,
-  axis: Tensor<Tidx>
-) -> StringTensor {
-  let op = TFE_Op("ReverseV2")
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  op.setAttr("T", TensorDataType(TF_STRING))
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(axis)
-  return op.execute(Int(1))
-}
-
-/// Elementwise computes the bitwise right-shift of `x` and `y`.
-///
-/// Performs a logical shift for unsigned integer types, and an arithmetic shift
-/// for signed integer types.
-///
-/// If `y` is negative, or greater than or equal to than the width of `x` in bits
-/// the result is implementation defined.
-@inlinable
-public static func rightShift<T: BinaryInteger & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("RightShift")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns element-wise integer closest to x.
-///
-/// If the result is midway between two representable values,
-/// the even representable is chosen.
-/// For example:
-///
-/// ```
-/// rint(-1.5) ==> -2.0
-/// rint(0.5000001) ==> 1.0
-/// rint([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) ==> [-2., -2., -0., 0., 2., 2., 2.]
-/// ```
-@inlinable
-public static func rint<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Rint")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Rolls the elements of a tensor along an axis.
-///
-/// The elements are shifted positively (towards larger indices) by the offset of
-/// `shift` along the dimension of `axis`. Negative `shift` values will shift
-/// elements in the opposite direction. Elements that roll passed the last position
-/// will wrap around to the first and vice versa. Multiple shifts along multiple
-/// axes may be specified.
-///
-/// For example:
-///
-/// ```
-/// # 't' is [0, 1, 2, 3, 4]
-/// roll(t, shift=2, axis=0) ==> [3, 4, 0, 1, 2]
-///
-/// # shifting along multiple dimensions
-/// # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
-/// roll(t, shift=[1, -2], axis=[0, 1]) ==> [[7, 8, 9, 5, 6], [2, 3, 4, 0, 1]]
-///
-/// # shifting along the same axis multiple times
-/// # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
-/// roll(t, shift=[2, -3], axis=[1, 1]) ==> [[1, 2, 3, 4, 0], [6, 7, 8, 9, 5]]
-/// ```
-///
-/// - Parameters:
-///   - shift: Dimension must be 0-D or 1-D. `shift[i]` specifies the number of places by which
-///     elements are shifted positively (towards larger indices) along the dimension
-///     specified by `axis[i]`. Negative shifts will roll the elements in the opposite
-///     direction.
-///   - axis: Dimension must be 0-D or 1-D. `axis[i]` specifies the dimension that the shift
-///     `shift[i]` should occur. If the same axis is referenced more than once, the
-///     total shift for that axis will be the sum of all the shifts that belong to that
-///     axis.
-///
-/// - Output output: Has the same shape and size as the input. The elements are shifted
-///   positively (towards larger indices) by the offsets of `shift` along the
-///   dimensions of `axis`.
-@inlinable
-public static func roll<
-    T: TensorFlowScalar,
-    Tshift: BinaryInteger & TensorFlowScalar,
-    Taxis: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  shift: Tensor<Tshift>,
-  axis: Tensor<Taxis>
-) -> Tensor<T> {
-  let op = TFE_Op("Roll")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tshift", Tshift.tensorFlowDataType)
-  op.setAttr("Taxis", Taxis.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(shift)
-  let _ = op.addInput(axis)
-  return op.execute(Int(1))
-}
-
-/// Rounds the values of a tensor to the nearest integer, element-wise.
-///
-/// Rounds half to even.  Also known as bankers rounding. If you want to round
-/// according to the current system rounding mode use std::cint.
-@inlinable
-public static func round<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Round")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Perform batches of RPC requests.
-///
-/// This op asynchronously performs either a single RPC request, or a batch
-/// of requests.  RPC requests are defined by three main parameters:
-///
-///   - `address` (the host+port or BNS address of the request)
-///   - `method` (the RPC method name for the request)
-///   - `request` (the serialized proto string, or vector of strings,
-///      of the RPC request argument).
-///
-/// For example, if you have an RPC service running on port localhost:2345,
-/// and its interface is configured with the following proto declaration:
-///
-/// ```
-/// service MyService {
-///   rpc MyMethod(MyRequestProto) returns (MyResponseProto) {
-///   }
-/// };
-/// ```
-///
-/// then call this op with arguments:
-///
-/// ```
-/// address = "localhost:2345"
-/// method = "MyService/MyMethod"
-/// ```
-///
-/// The `request` tensor is a string tensor representing serialized `MyRequestProto`
-/// strings; and the output string tensor `response` will have the same shape
-/// and contain (upon successful completion) corresponding serialized
-/// `MyResponseProto` strings.
-///
-/// For example, to send a single, empty, `MyRequestProto`, call
-/// this op with `request = ""`.  To send 5 **parallel** empty requests,
-/// call this op with `request = ["", "", "", "", ""]`.
-///
-/// More generally, one can create a batch of `MyRequestProto` serialized protos
-/// from regular batched tensors using the `encode_proto` op, and convert
-/// the response `MyResponseProto` serialized protos to batched tensors
-/// using the `decode_proto` op.
-///
-/// **NOTE** Working with serialized proto strings is faster than instantiating
-/// actual proto objects in memory, so no performance degradation is expected
-/// compared to writing custom kernels for this workflow.
-///
-/// If the connection fails or the remote worker returns an error
-/// status, the op reraises this exception locally.
-///
-/// See the `TryRpc` op if you prefer to handle RPC failures manually in the graph.
-///
-/// - Parameters:
-///   - address: `0-D` or `1-D`.  The address (i.e. host_name:port) of the RPC server.
-///     If this tensor has more than 1 element, then multiple parallel rpc requests
-///     are sent.  This argument broadcasts with `method` and `request`.
-///   - method: `0-D` or `1-D`.  The method address on the RPC server.
-///     If this tensor has more than 1 element, then multiple parallel rpc requests
-///     are sent.  This argument broadcasts with `address` and `request`.
-///   - request: `0-D` or `1-D`.  Serialized proto strings: the rpc request argument.
-///     If this tensor has more than 1 element, then multiple parallel rpc requests
-///     are sent.  This argument broadcasts with `address` and `method`.
-///
-/// - Attrs:
-///   - protocol: RPC protocol to use.  Empty string means use the default protocol.
-///     Options include 'grpc'.
-///   - fail_fast: `boolean`. If `true` (default), then failures to connect
-///     (i.e., the server does not immediately respond) cause an RPC failure.
-///   - timeout_in_ms: `int`. If `0` (default), then the kernel will run the RPC
-///     request and only time out if the RPC deadline passes or the session times out.
-///     If this value is greater than `0`, then the op will raise an exception if
-///     the RPC takes longer than `timeout_in_ms`.
-///
-/// - Output response: Same shape as `request`. Serialized proto strings: the rpc responses.
-@inlinable
-public static func rpc(
-  address: StringTensor,
-  method: StringTensor,
-  request: StringTensor,
-  protocol_: String,
-  failFast: Bool = true,
-  timeoutInMs: Int64 = 0
-) -> StringTensor {
-  let op = TFE_Op("Rpc")
-  op.setAttr("protocol", protocol_)
-  op.setAttr("fail_fast", failFast)
-  op.setAttr("timeout_in_ms", timeoutInMs)
-  let _ = op.addInput(address)
-  let _ = op.addInput(method)
-  let _ = op.addInput(request)
-  return op.execute(Int(1))
-}
-
-/// Computes reciprocal of square root of x element-wise.
-///
-/// I.e., \\(y = 1 / \sqrt{x}\\).
-@inlinable
-public static func rsqrt<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Rsqrt")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient for the rsqrt of `x` wrt its input.
-///
-/// Specifically, `grad = dy * -0.5 * y^3`, where `y = rsqrt(x)`, and `dy`
-/// is the corresponding input gradient.
-@inlinable
-public static func rsqrtGrad<T: FloatingPoint & TensorFlowScalar>(
-  _ y: Tensor<T>,
-  dy: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("RsqrtGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(y)
-  let _ = op.addInput(dy)
-  return op.execute(Int(1))
-}
-
-/// Generate a single randomly distorted bounding box for an image.
-///
-/// Bounding box annotations are often supplied in addition to ground-truth labels
-/// in image recognition or object localization tasks. A common technique for
-/// training such a system is to randomly distort an image while preserving
-/// its content, i.e. *data augmentation*. This Op outputs a randomly distorted
-/// localization of an object, i.e. bounding box, given an `image_size`,
-/// `bounding_boxes` and a series of constraints.
-///
-/// The output of this Op is a single bounding box that may be used to crop the
-/// original image. The output is returned as 3 tensors: `begin`, `size` and
-/// `bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the
-/// image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize
-/// what the bounding box looks like.
-///
-/// Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The
-/// bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
-/// height of the underlying image.
-///
-/// For example,
-///
-/// ```python
-///     # Generate a single distorted bounding box.
-///     begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
-///         tf.shape(image),
-///         bounding_boxes=bounding_boxes)
-///
-///     # Draw the bounding box in an image summary.
-///     image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0),
-///                                                   bbox_for_draw)
-///     tf.summary.image('images_with_box', image_with_box)
-///
-///     # Employ the bounding box to distort the image.
-///     distorted_image = tf.slice(image, begin, size)
-/// ```
-///
-/// Note that if no bounding box information is available, setting
-/// `use_image_if_no_bounding_boxes = true` will assume there is a single implicit
-/// bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is
-/// false and no bounding boxes are supplied, an error is raised.
-///
-/// - Parameters:
-///   - image_size: 1-D, containing `[height, width, channels]`.
-///   - bounding_boxes: 3-D with shape `[batch, N, 4]` describing the N bounding boxes
-///     associated with the image.
-///
-/// - Attrs:
-///   - seed: If either `seed` or `seed2` are set to non-zero, the random number
-///     generator is seeded by the given `seed`.  Otherwise, it is seeded by a random
-///     seed.
-///   - seed2: A second seed to avoid seed collision.
-///   - min_object_covered: The cropped area of the image must contain at least this
-///     fraction of any bounding box supplied. The value of this parameter should be
-///     non-negative. In the case of 0, the cropped area does not need to overlap
-///     any of the bounding boxes supplied.
-///   - aspect_ratio_range: The cropped area of the image must have an aspect ratio =
-///     width / height within this range.
-///   - area_range: The cropped area of the image must contain a fraction of the
-///     supplied image within this range.
-///   - max_attempts: Number of attempts at generating a cropped region of the image
-///     of the specified constraints. After `max_attempts` failures, return the entire
-///     image.
-///   - use_image_if_no_bounding_boxes: Controls behavior if no bounding boxes supplied.
-///     If true, assume an implicit bounding box covering the whole input. If false,
-///     raise an error.
-///
-/// - Outputs:
-///   - begin: 1-D, containing `[offset_height, offset_width, 0]`. Provide as input to
-///     `tf.slice`.
-///   - size: 1-D, containing `[target_height, target_width, -1]`. Provide as input to
-///     `tf.slice`.
-///   - bboxes: 3-D with shape `[1, 1, 4]` containing the distorted bounding box.
-///     Provide as input to `tf.image.draw_bounding_boxes`.
-@inlinable
-public static func sampleDistortedBoundingBox<T: BinaryInteger & TensorFlowScalar>(
-  imageSize: Tensor<T>,
-  boundingBoxes: Tensor<Float>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0,
-  minObjectCovered: Double = 0.1,
-  aspectRatioRange: [Double] = [0.75, 1.33],
-  areaRange: [Double] = [0.05, 1],
-  maxAttempts: Int64 = 100,
-  useImageIfNoBoundingBoxes: Bool = false
-) -> (begin: Tensor<T>, size: Tensor<T>, bboxes: Tensor<Float>) {
-  let op = TFE_Op("SampleDistortedBoundingBox")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("min_object_covered", minObjectCovered)
-  op.setAttr("aspect_ratio_range", aspectRatioRange)
-  op.setAttr("area_range", areaRange)
-  op.setAttr("max_attempts", maxAttempts)
-  op.setAttr("use_image_if_no_bounding_boxes", useImageIfNoBoundingBoxes)
-  let _ = op.addInput(imageSize)
-  let _ = op.addInput(boundingBoxes)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Generate a single randomly distorted bounding box for an image.
-///
-/// Bounding box annotations are often supplied in addition to ground-truth labels
-/// in image recognition or object localization tasks. A common technique for
-/// training such a system is to randomly distort an image while preserving
-/// its content, i.e. *data augmentation*. This Op outputs a randomly distorted
-/// localization of an object, i.e. bounding box, given an `image_size`,
-/// `bounding_boxes` and a series of constraints.
-///
-/// The output of this Op is a single bounding box that may be used to crop the
-/// original image. The output is returned as 3 tensors: `begin`, `size` and
-/// `bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the
-/// image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize
-/// what the bounding box looks like.
-///
-/// Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The
-/// bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
-/// height of the underlying image.
-///
-/// For example,
-///
-/// ```python
-///     # Generate a single distorted bounding box.
-///     begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
-///         tf.shape(image),
-///         bounding_boxes=bounding_boxes)
-///
-///     # Draw the bounding box in an image summary.
-///     image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0),
-///                                                   bbox_for_draw)
-///     tf.summary.image('images_with_box', image_with_box)
-///
-///     # Employ the bounding box to distort the image.
-///     distorted_image = tf.slice(image, begin, size)
-/// ```
-///
-/// Note that if no bounding box information is available, setting
-/// `use_image_if_no_bounding_boxes = true` will assume there is a single implicit
-/// bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is
-/// false and no bounding boxes are supplied, an error is raised.
-///
-/// - Parameters:
-///   - image_size: 1-D, containing `[height, width, channels]`.
-///   - bounding_boxes: 3-D with shape `[batch, N, 4]` describing the N bounding boxes
-///     associated with the image.
-///   - min_object_covered: The cropped area of the image must contain at least this
-///     fraction of any bounding box supplied. The value of this parameter should be
-///     non-negative. In the case of 0, the cropped area does not need to overlap
-///     any of the bounding boxes supplied.
-///
-/// - Attrs:
-///   - seed: If either `seed` or `seed2` are set to non-zero, the random number
-///     generator is seeded by the given `seed`.  Otherwise, it is seeded by a random
-///     seed.
-///   - seed2: A second seed to avoid seed collision.
-///   - aspect_ratio_range: The cropped area of the image must have an aspect ratio =
-///     width / height within this range.
-///   - area_range: The cropped area of the image must contain a fraction of the
-///     supplied image within this range.
-///   - max_attempts: Number of attempts at generating a cropped region of the image
-///     of the specified constraints. After `max_attempts` failures, return the entire
-///     image.
-///   - use_image_if_no_bounding_boxes: Controls behavior if no bounding boxes supplied.
-///     If true, assume an implicit bounding box covering the whole input. If false,
-///     raise an error.
-///
-/// - Outputs:
-///   - begin: 1-D, containing `[offset_height, offset_width, 0]`. Provide as input to
-///     `tf.slice`.
-///   - size: 1-D, containing `[target_height, target_width, -1]`. Provide as input to
-///     `tf.slice`.
-///   - bboxes: 3-D with shape `[1, 1, 4]` containing the distorted bounding box.
-///     Provide as input to `tf.image.draw_bounding_boxes`.
-@inlinable
-public static func sampleDistortedBoundingBoxV2<T: BinaryInteger & TensorFlowScalar>(
-  imageSize: Tensor<T>,
-  boundingBoxes: Tensor<Float>,
-  minObjectCovered: Tensor<Float>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0,
-  aspectRatioRange: [Double] = [0.75, 1.33],
-  areaRange: [Double] = [0.05, 1],
-  maxAttempts: Int64 = 100,
-  useImageIfNoBoundingBoxes: Bool = false
-) -> (begin: Tensor<T>, size: Tensor<T>, bboxes: Tensor<Float>) {
-  let op = TFE_Op("SampleDistortedBoundingBoxV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("aspect_ratio_range", aspectRatioRange)
-  op.setAttr("area_range", areaRange)
-  op.setAttr("max_attempts", maxAttempts)
-  op.setAttr("use_image_if_no_bounding_boxes", useImageIfNoBoundingBoxes)
-  let _ = op.addInput(imageSize)
-  let _ = op.addInput(boundingBoxes)
-  let _ = op.addInput(minObjectCovered)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Creates a dataset that contains `rate` elements from the `input_dataset`.
-///
-/// - Parameters:
-///   - rate: A scalar representing the sample rate of elements from the `input_dataset`
-///     that should be taken.
-///   - seed: A scalar representing seed of random number generator.
-///   - seed2: A scalar representing seed2 of random number generator.
-@inlinable
-public static func samplingDataset(
-  inputDataset: VariantHandle,
-  rate: Tensor<Float>,
-  seed: Tensor<Int64>,
-  seed2: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("SamplingDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(rate)
-  let _ = op.addInput(seed)
-  let _ = op.addInput(seed2)
-  return op.execute(Int(1))
-}
-
-/// Saves the input tensors to disk.
-///
-/// The size of `tensor_names` must match the number of tensors in `data`. `data[i]`
-/// is written to `filename` with name `tensor_names[i]`.
-///
-/// See also `SaveSlices`.
-///
-/// - Parameters:
-///   - filename: Must have a single element. The name of the file to which we write
-///     the tensor.
-///   - tensor_names: Shape `[N]`. The names of the tensors to be saved.
-///   - data: `N` tensors to save.
-@inlinable
-public static func save<T: TensorArrayProtocol>(
-  filename: StringTensor,
-  tensorNames: StringTensor,
-  data: T
-) {
-  let op = TFE_Op("Save")
-  op.setAttr("T", data._typeList)
-  let _ = op.addInput(filename)
-  let _ = op.addInput(tensorNames)
-  let _ = op.addInputList(data)
-  op.execute()
-}
-
-/// Saves input tensors slices to disk.
-///
-/// This is like `Save` except that tensors can be listed in the saved file as being
-/// a slice of a larger tensor.  `shapes_and_slices` specifies the shape of the
-/// larger tensor and the slice that this tensor covers. `shapes_and_slices` must
-/// have as many elements as `tensor_names`.
-///
-/// Elements of the `shapes_and_slices` input must either be:
-///
-/// *  The empty string, in which case the corresponding tensor is
-///    saved normally.
-/// *  A string of the form `dim0 dim1 ... dimN-1 slice-spec` where the
-///    `dimI` are the dimensions of the larger tensor and `slice-spec`
-///    specifies what part is covered by the tensor to save.
-///
-/// `slice-spec` itself is a `:`-separated list: `slice0:slice1:...:sliceN-1`
-/// where each `sliceI` is either:
-///
-/// *  The string `-` meaning that the slice covers all indices of this dimension
-/// *  `start,length` where `start` and `length` are integers.  In that
-///    case the slice covers `length` indices starting at `start`.
-///
-/// See also `Save`.
-///
-/// - Parameters:
-///   - filename: Must have a single element. The name of the file to which we write the
-///     tensor.
-///   - tensor_names: Shape `[N]`. The names of the tensors to be saved.
-///   - shapes_and_slices: Shape `[N]`.  The shapes and slice specifications to use when
-///     saving the tensors.
-///   - data: `N` tensors to save.
-@inlinable
-public static func saveSlices<T: TensorArrayProtocol>(
-  filename: StringTensor,
-  tensorNames: StringTensor,
-  shapesAndSlices: StringTensor,
-  data: T
-) {
-  let op = TFE_Op("SaveSlices")
-  op.setAttr("T", data._typeList)
-  let _ = op.addInput(filename)
-  let _ = op.addInput(tensorNames)
-  let _ = op.addInput(shapesAndSlices)
-  let _ = op.addInputList(data)
-  op.execute()
-}
-
-/// Saves tensors in V2 checkpoint format.
-///
-/// By default, saves the named tensors in full.  If the caller wishes to save
-/// specific slices of full tensors, "shape_and_slices" should be non-empty strings
-/// and correspondingly well-formed.
-///
-/// - Parameters:
-///   - prefix: Must have a single element. The prefix of the V2 checkpoint to which we
-///     write the tensors.
-///   - tensor_names: shape {N}. The names of the tensors to be saved.
-///   - shape_and_slices: shape {N}.  The slice specs of the tensors to be saved.
-///     Empty strings indicate that they are non-partitioned tensors.
-///   - tensors: `N` tensors to save.
-@inlinable
-public static func saveV2<Dtypes: TensorArrayProtocol>(
-  prefix: StringTensor,
-  tensorNames: StringTensor,
-  shapeAndSlices: StringTensor,
-  tensors: Dtypes
-) {
-  let op = TFE_Op("SaveV2")
-  op.setAttr("dtypes", tensors._typeList)
-  let _ = op.addInput(prefix)
-  let _ = op.addInput(tensorNames)
-  let _ = op.addInput(shapeAndSlices)
-  let _ = op.addInputList(tensors)
-  op.execute()
-}
-
-/// Outputs a `Summary` protocol buffer with scalar values.
-///
-/// The input `tags` and `values` must have the same shape.  The generated summary
-/// has a summary value for each tag-value pair in `tags` and `values`.
-///
-/// - Parameters:
-///   - tags: Tags for the summary.
-///   - values: Same shape as `tags.  Values for the summary.
-///
-/// - Output summary: Scalar.  Serialized `Summary` protocol buffer.
-@inlinable
-public static func scalarSummary<T: Numeric & TensorFlowScalar>(
-  tags: StringTensor,
-  _ values: Tensor<T>
-) -> StringTensor {
-  let op = TFE_Op("ScalarSummary")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(tags)
-  let _ = op.addInput(values)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func scaleAndTranslate<T: Numeric & TensorFlowScalar>(
-  images: Tensor<T>,
-  size: Tensor<Int32>,
-  scale: Tensor<Float>,
-  translation: Tensor<Float>,
-  kernelType: String = "lanczos3",
-  antialias: Bool = true
-) -> Tensor<Float> {
-  let op = TFE_Op("ScaleAndTranslate")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("kernel_type", kernelType)
-  op.setAttr("antialias", antialias)
-  let _ = op.addInput(images)
-  let _ = op.addInput(size)
-  let _ = op.addInput(scale)
-  let _ = op.addInput(translation)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func scaleAndTranslateGrad<T: FloatingPoint & TensorFlowScalar>(
-  grads: Tensor<T>,
-  originalImage: Tensor<T>,
-  scale: Tensor<Float>,
-  translation: Tensor<Float>,
-  kernelType: String = "lanczos3",
-  antialias: Bool = true
-) -> Tensor<T> {
-  let op = TFE_Op("ScaleAndTranslateGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("kernel_type", kernelType)
-  op.setAttr("antialias", antialias)
-  let _ = op.addInput(grads)
-  let _ = op.addInput(originalImage)
-  let _ = op.addInput(scale)
-  let _ = op.addInput(translation)
-  return op.execute(Int(1))
-}
-
-/// Scatter `updates` into a new tensor according to `indices`.
-///
-/// Creates a new tensor by applying sparse `updates` to individual values or
-/// slices within a tensor (initially zero for numeric, empty for string) of
-/// the given `shape` according to indices.  This operator is the inverse of the
-/// `tf.gather_nd` operator which extracts values or slices from a given tensor.
-///
-/// This operation is similar to tensor_scatter_add, except that the tensor is
-/// zero-initialized. Calling `tf.scatter_nd(indices, values, shape)` is identical
-/// to `tensor_scatter_add(tf.zeros(shape, values.dtype), indices, values)`
-///
-/// If `indices` contains duplicates, then their updates are accumulated (summed).
-///
-/// **WARNING**: The order in which updates are applied is nondeterministic, so the
-/// output will be nondeterministic if `indices` contains duplicates -- because
-/// of some numerical approximation issues, numbers summed in different order
-/// may yield different results.
-///
-/// `indices` is an integer tensor containing indices into a new tensor of shape
-/// `shape`.  The last dimension of `indices` can be at most the rank of `shape`:
-///
-///     indices.shape[-1] <= shape.rank
-///
-/// The last dimension of `indices` corresponds to indices into elements
-/// (if `indices.shape[-1] = shape.rank`) or slices
-/// (if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
-/// `shape`.  `updates` is a tensor with shape
-///
-///     indices.shape[:-1] + shape[indices.shape[-1]:]
-///
-/// The simplest form of scatter is to insert individual elements in a tensor by
-/// index. For example, say we want to insert 4 scattered elements in a rank-1
-/// tensor with 8 elements.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd1.png" alt>
-/// </div>
-///
-/// In Python, this scatter operation would look like this:
-///
-/// ```python
-///     indices = tf.constant([[4], [3], [1], [7]])
-///     updates = tf.constant([9, 10, 11, 12])
-///     shape = tf.constant([8])
-///     scatter = tf.scatter_nd(indices, updates, shape)
-///     with tf.Session() as sess:
-///       print(sess.run(scatter))
-/// ```
-///
-/// The resulting tensor would look like this:
-///
-///     [0, 11, 0, 10, 9, 0, 0, 12]
-///
-/// We can also, insert entire slices of a higher rank tensor all at once. For
-/// example, if we wanted to insert two slices in the first dimension of a
-/// rank-3 tensor with two matrices of new values.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd2.png" alt>
-/// </div>
-///
-/// In Python, this scatter operation would look like this:
-///
-/// ```python
-///     indices = tf.constant([[0], [2]])
-///     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
-///                             [7, 7, 7, 7], [8, 8, 8, 8]],
-///                            [[5, 5, 5, 5], [6, 6, 6, 6],
-///                             [7, 7, 7, 7], [8, 8, 8, 8]]])
-///     shape = tf.constant([4, 4, 4])
-///     scatter = tf.scatter_nd(indices, updates, shape)
-///     with tf.Session() as sess:
-///       print(sess.run(scatter))
-/// ```
-///
-/// The resulting tensor would look like this:
-///
-///     [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
-///      [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
-///      [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
-///      [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]]
-///
-/// Note that on CPU, if an out of bound index is found, an error is returned.
-/// On GPU, if an out of bound index is found, the index is ignored.
-///
-/// - Parameters:
-///   - indices: Index tensor.
-///   - updates: Updates to scatter into output.
-///   - shape: 1-D. The shape of the resulting tensor.
-///
-/// - Output output: A new tensor with the given shape and updates applied according
-///   to the indices.
-@inlinable
-public static func scatterNd<
-    T: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  indices: Tensor<Tindices>,
-  updates: Tensor<T>,
-  shape: Tensor<Tindices>
-) -> Tensor<T> {
-  let op = TFE_Op("ScatterNd")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Applies sparse addition to `input` using individual values or slices
-///
-/// from `updates` according to indices `indices`.  The updates are non-aliasing:
-/// `input` is only modified in-place if no other operations will use it.
-/// Otherwise, a copy of `input` is made.  This operation has a gradient with
-/// respect to both `input` and `updates`.
-///
-/// `input` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
-///
-/// `indices` must be integer tensor, containing indices into `input`.
-/// It must be shape \\([d_0, ..., d_{Q-2}, K]\\) where `0 < K <= P`.
-///
-/// The innermost dimension of `indices` (with length `K`) corresponds to
-/// indices into elements (if `K = P`) or `(P-K)`-dimensional slices
-/// (if `K < P`) along the `K`th dimension of `input`.
-///
-/// `updates` is `Tensor` of rank `Q-1+P-K` with shape:
-///
-/// $$[d_0, ..., d_{Q-2}, input.shape[K], ..., input.shape[P-1]].$$
-///
-/// For example, say we want to add 4 scattered elements to a rank-1 tensor to 8
-/// elements. In Python, that addition would look like this:
-///
-///     input = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
-///     indices = tf.constant([[4], [3], [1], [7]])
-///     updates = tf.constant([9, 10, 11, 12])
-///     output = tf.scatter_nd_non_aliasing_add(input, indices, updates)
-///     with tf.Session() as sess:
-///       print(sess.run(output))
-///
-/// The resulting value `output` would look like this:
-///
-///     [1, 13, 3, 14, 14, 6, 7, 20]
-///
-/// See `tf.scatter_nd` for more details about how to make updates to slices.
-///
-/// - Parameters:
-///   - input: A Tensor.
-///   - indices: A Tensor. Must be one of the following types: `int32`, `int64`.
-///     A tensor of indices into `input`.
-///   - updates: A Tensor. Must have the same type as ref. A tensor of updated values
-///     to add to `input`.
-///
-/// - Output output: A `Tensor` with the same shape as `input`, containing values of `input`
-///   updated with `updates`.
-@inlinable
-public static func scatterNdNonAliasingAdd<
-    T: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  indices: Tensor<Tindices>,
-  updates: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("ScatterNdNonAliasingAdd")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  return op.execute(Int(1))
-}
-
-/// Computes fingerprints of the input strings.
-///
-/// - Parameter input: vector of strings to compute fingerprints on.
-///
-/// - Output output: a (N,2) shaped matrix where N is the number of elements in the input
-///   vector. Each row contains the low and high parts of the fingerprint.
-@inlinable
-public static func sdcaFprint(
-  _ input: StringTensor
-) -> Tensor<Int64> {
-  let op = TFE_Op("SdcaFprint")
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Distributed version of Stochastic Dual Coordinate Ascent (SDCA) optimizer for
-///
-/// linear models with L1 + L2 regularization. As global optimization objective is
-/// strongly-convex, the optimizer optimizes the dual objective at each step. The
-/// optimizer applies each update one example at a time. Examples are sampled
-/// uniformly, and the optimizer is learning rate free and enjoys linear convergence
-/// rate.
-///
-/// [Proximal Stochastic Dual Coordinate Ascent](http://arxiv.org/pdf/1211.2717v1.pdf).<br>
-/// Shai Shalev-Shwartz, Tong Zhang. 2012
-///
-/// $$Loss Objective = \sum f_{i} (wx_{i}) + (l2 / 2) * |w|^2 + l1 * |w|$$
-///
-/// [Adding vs. Averaging in Distributed Primal-Dual Optimization](http://arxiv.org/abs/1502.03508).<br>
-/// Chenxin Ma, Virginia Smith, Martin Jaggi, Michael I. Jordan,
-/// Peter Richtarik, Martin Takac. 2015
-///
-/// [Stochastic Dual Coordinate Ascent with Adaptive Probabilities](https://arxiv.org/abs/1502.08053).<br>
-/// Dominik Csiba, Zheng Qu, Peter Richtarik. 2015
-///
-/// - Parameters:
-///   - sparse_example_indices: a list of vectors which contain example indices.
-///   - sparse_feature_indices: a list of vectors which contain feature indices.
-///   - sparse_feature_values: a list of vectors which contains feature value
-///     associated with each feature group.
-///   - dense_features: a list of matrices which contains the dense feature values.
-///   - example_weights: a vector which contains the weight associated with each
-///     example.
-///   - example_labels: a vector which contains the label/target associated with each
-///     example.
-///   - sparse_indices: a list of vectors where each value is the indices which has
-///     corresponding weights in sparse_weights. This field maybe omitted for the
-///     dense approach.
-///   - sparse_weights: a list of vectors where each value is the weight associated with
-///     a sparse feature group.
-///   - dense_weights: a list of vectors where the values are the weights associated
-///     with a dense feature group.
-///   - example_state_data: a list of vectors containing the example state data.
-///
-/// - Attrs:
-///   - loss_type: Type of the primal loss. Currently SdcaSolver supports logistic,
-///     squared and hinge losses.
-///   - adaptative: Whether to use Adaptive SDCA for the inner loop.
-///   - num_sparse_features: Number of sparse feature groups to train on.
-///   - num_sparse_features_with_values: Number of sparse feature groups with values
-///     associated with it, otherwise implicitly treats values as 1.0.
-///   - num_dense_features: Number of dense feature groups to train on.
-///   - l1: Symmetric l1 regularization strength.
-///   - l2: Symmetric l2 regularization strength.
-///   - num_loss_partitions: Number of partitions of the global loss function.
-///   - num_inner_iterations: Number of iterations per mini-batch.
-///
-/// - Outputs:
-///   - out_example_state_data: a list of vectors containing the updated example state
-///     data.
-///   - out_delta_sparse_weights: a list of vectors where each value is the delta
-///     weights associated with a sparse feature group.
-///   - out_delta_dense_weights: a list of vectors where the values are the delta
-///     weights associated with a dense feature group.
-@inlinable
-public static func sdcaOptimizer(
-  sparseExampleIndices: [Tensor<Int64>],
-  sparseFeatureIndices: [Tensor<Int64>],
-  sparseFeatureValues: [Tensor<Float>],
-  denseFeatures: [Tensor<Float>],
-  exampleWeights: Tensor<Float>,
-  exampleLabels: Tensor<Float>,
-  sparseIndices: [Tensor<Int64>],
-  sparseWeights: [Tensor<Float>],
-  denseWeights: [Tensor<Float>],
-  exampleStateData: Tensor<Float>,
-  lossType: LossType,
-  adaptative: Bool = false,
-  l1: Double,
-  l2: Double,
-  numLossPartitions: Int64,
-  numInnerIterations: Int64
-) -> (outExampleStateData: Tensor<Float>, outDeltaSparseWeights: [Tensor<Float>], outDeltaDenseWeights: [Tensor<Float>]) {
-  let op = TFE_Op("SdcaOptimizer")
-  op.setAttr("loss_type", lossType.cName)
-  op.setAttr("adaptative", adaptative)
-  op.setAttr("num_sparse_features", sparseExampleIndices.count)
-  op.setAttr("num_sparse_features_with_values", sparseFeatureValues.count)
-  op.setAttr("num_dense_features", denseFeatures.count)
-  op.setAttr("l1", l1)
-  op.setAttr("l2", l2)
-  op.setAttr("num_loss_partitions", numLossPartitions)
-  op.setAttr("num_inner_iterations", numInnerIterations)
-  let _ = op.addInputList(sparseExampleIndices)
-  let _ = op.addInputList(sparseFeatureIndices)
-  let _ = op.addInputList(sparseFeatureValues)
-  let _ = op.addInputList(denseFeatures)
-  let _ = op.addInput(exampleWeights)
-  let _ = op.addInput(exampleLabels)
-  let _ = op.addInputList(sparseIndices)
-  let _ = op.addInputList(sparseWeights)
-  let _ = op.addInputList(denseWeights)
-  let _ = op.addInput(exampleStateData)
-  return op.execute(Int(1), Int(sparseExampleIndices.count), Int(denseFeatures.count))
-}
-
-/// Distributed version of Stochastic Dual Coordinate Ascent (SDCA) optimizer for
-///
-/// linear models with L1 + L2 regularization. As global optimization objective is
-/// strongly-convex, the optimizer optimizes the dual objective at each step. The
-/// optimizer applies each update one example at a time. Examples are sampled
-/// uniformly, and the optimizer is learning rate free and enjoys linear convergence
-/// rate.
-///
-/// [Proximal Stochastic Dual Coordinate Ascent](http://arxiv.org/pdf/1211.2717v1.pdf).<br>
-/// Shai Shalev-Shwartz, Tong Zhang. 2012
-///
-/// $$Loss Objective = \sum f_{i} (wx_{i}) + (l2 / 2) * |w|^2 + l1 * |w|$$
-///
-/// [Adding vs. Averaging in Distributed Primal-Dual Optimization](http://arxiv.org/abs/1502.03508).<br>
-/// Chenxin Ma, Virginia Smith, Martin Jaggi, Michael I. Jordan,
-/// Peter Richtarik, Martin Takac. 2015
-///
-/// [Stochastic Dual Coordinate Ascent with Adaptive Probabilities](https://arxiv.org/abs/1502.08053).<br>
-/// Dominik Csiba, Zheng Qu, Peter Richtarik. 2015
-///
-/// - Parameters:
-///   - sparse_example_indices: a list of vectors which contain example indices.
-///   - sparse_feature_indices: a list of vectors which contain feature indices.
-///   - sparse_feature_values: a list of vectors which contains feature value
-///     associated with each feature group.
-///   - dense_features: a list of matrices which contains the dense feature values.
-///   - example_weights: a vector which contains the weight associated with each
-///     example.
-///   - example_labels: a vector which contains the label/target associated with each
-///     example.
-///   - sparse_indices: a list of vectors where each value is the indices which has
-///     corresponding weights in sparse_weights. This field maybe omitted for the
-///     dense approach.
-///   - sparse_weights: a list of vectors where each value is the weight associated with
-///     a sparse feature group.
-///   - dense_weights: a list of vectors where the values are the weights associated
-///     with a dense feature group.
-///   - example_state_data: a list of vectors containing the example state data.
-///
-/// - Attrs:
-///   - loss_type: Type of the primal loss. Currently SdcaSolver supports logistic,
-///     squared and hinge losses.
-///   - adaptive: Whether to use Adaptive SDCA for the inner loop.
-///   - num_sparse_features: Number of sparse feature groups to train on.
-///   - num_sparse_features_with_values: Number of sparse feature groups with values
-///     associated with it, otherwise implicitly treats values as 1.0.
-///   - num_dense_features: Number of dense feature groups to train on.
-///   - l1: Symmetric l1 regularization strength.
-///   - l2: Symmetric l2 regularization strength.
-///   - num_loss_partitions: Number of partitions of the global loss function.
-///   - num_inner_iterations: Number of iterations per mini-batch.
-///
-/// - Outputs:
-///   - out_example_state_data: a list of vectors containing the updated example state
-///     data.
-///   - out_delta_sparse_weights: a list of vectors where each value is the delta
-///     weights associated with a sparse feature group.
-///   - out_delta_dense_weights: a list of vectors where the values are the delta
-///     weights associated with a dense feature group.
-@inlinable
-public static func sdcaOptimizerV2(
-  sparseExampleIndices: [Tensor<Int64>],
-  sparseFeatureIndices: [Tensor<Int64>],
-  sparseFeatureValues: [Tensor<Float>],
-  denseFeatures: [Tensor<Float>],
-  exampleWeights: Tensor<Float>,
-  exampleLabels: Tensor<Float>,
-  sparseIndices: [Tensor<Int64>],
-  sparseWeights: [Tensor<Float>],
-  denseWeights: [Tensor<Float>],
-  exampleStateData: Tensor<Float>,
-  lossType: LossType,
-  adaptive: Bool = false,
-  l1: Double,
-  l2: Double,
-  numLossPartitions: Int64,
-  numInnerIterations: Int64
-) -> (outExampleStateData: Tensor<Float>, outDeltaSparseWeights: [Tensor<Float>], outDeltaDenseWeights: [Tensor<Float>]) {
-  let op = TFE_Op("SdcaOptimizerV2")
-  op.setAttr("loss_type", lossType.cName)
-  op.setAttr("adaptive", adaptive)
-  op.setAttr("num_sparse_features", sparseExampleIndices.count)
-  op.setAttr("num_sparse_features_with_values", sparseFeatureValues.count)
-  op.setAttr("num_dense_features", denseFeatures.count)
-  op.setAttr("l1", l1)
-  op.setAttr("l2", l2)
-  op.setAttr("num_loss_partitions", numLossPartitions)
-  op.setAttr("num_inner_iterations", numInnerIterations)
-  let _ = op.addInputList(sparseExampleIndices)
-  let _ = op.addInputList(sparseFeatureIndices)
-  let _ = op.addInputList(sparseFeatureValues)
-  let _ = op.addInputList(denseFeatures)
-  let _ = op.addInput(exampleWeights)
-  let _ = op.addInput(exampleLabels)
-  let _ = op.addInputList(sparseIndices)
-  let _ = op.addInputList(sparseWeights)
-  let _ = op.addInputList(denseWeights)
-  let _ = op.addInput(exampleStateData)
-  return op.execute(Int(1), Int(sparseExampleIndices.count), Int(denseFeatures.count))
-}
-
-/// Computes the maximum along segments of a tensor.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
-/// for an explanation of segments.
-///
-/// Computes a tensor such that
-/// \\(output_i = \max_j(data_j)\\) where `max` is over `j` such
-/// that `segment_ids[j] == i`.
-///
-/// If the max is empty for a given segment ID `i`, `output[i] = 0`.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentMax.png" alt>
-/// </div>
-///
-/// For example:
-///
-/// ```
-/// c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
-/// tf.segment_max(c, tf.constant([0, 0, 1]))
-/// # ==> [[4, 3, 3, 4],
-/// #      [5, 6, 7, 8]]
-/// ```
-///
-///
-/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
-///   first dimension.  Values should be sorted and can be repeated.
-///
-/// - Output output: Has same shape as data, except for dimension 0 which
-///   has size `k`, the number of segments.
-@inlinable
-public static func segmentMax<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  segmentIds: Tensor<Tindices>
-) -> Tensor<T> {
-  let op = TFE_Op("SegmentMax")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(segmentIds)
-  return op.execute(Int(1))
-}
-
-/// Computes the mean along segments of a tensor.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
-/// for an explanation of segments.
-///
-/// Computes a tensor such that
-/// \\(output_i = \frac{\sum_j data_j}{N}\\) where `mean` is
-/// over `j` such that `segment_ids[j] == i` and `N` is the total number of
-/// values summed.
-///
-/// If the mean is empty for a given segment ID `i`, `output[i] = 0`.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentMean.png" alt>
-/// </div>
-///
-/// For example:
-///
-/// ```
-/// c = tf.constant([[1.0,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
-/// tf.segment_mean(c, tf.constant([0, 0, 1]))
-/// # ==> [[2.5, 2.5, 2.5, 2.5],
-/// #      [5, 6, 7, 8]]
-/// ```
-///
-///
-/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
-///   first dimension.  Values should be sorted and can be repeated.
-///
-/// - Output output: Has same shape as data, except for dimension 0 which
-///   has size `k`, the number of segments.
-@inlinable
-public static func segmentMean<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  segmentIds: Tensor<Tindices>
-) -> Tensor<T> {
-  let op = TFE_Op("SegmentMean")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(segmentIds)
-  return op.execute(Int(1))
-}
-
-/// Computes the minimum along segments of a tensor.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
-/// for an explanation of segments.
-///
-/// Computes a tensor such that
-/// \\(output_i = \min_j(data_j)\\) where `min` is over `j` such
-/// that `segment_ids[j] == i`.
-///
-/// If the min is empty for a given segment ID `i`, `output[i] = 0`.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentMin.png" alt>
-/// </div>
-///
-/// For example:
-///
-/// ```
-/// c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
-/// tf.segment_min(c, tf.constant([0, 0, 1]))
-/// # ==> [[1, 2, 2, 1],
-/// #      [5, 6, 7, 8]]
-/// ```
-///
-/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
-///   first dimension.  Values should be sorted and can be repeated.
-///
-/// - Output output: Has same shape as data, except for dimension 0 which
-///   has size `k`, the number of segments.
-@inlinable
-public static func segmentMin<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  segmentIds: Tensor<Tindices>
-) -> Tensor<T> {
-  let op = TFE_Op("SegmentMin")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(segmentIds)
-  return op.execute(Int(1))
-}
-
-/// Computes the product along segments of a tensor.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
-/// for an explanation of segments.
-///
-/// Computes a tensor such that
-/// \\(output_i = \prod_j data_j\\) where the product is over `j` such
-/// that `segment_ids[j] == i`.
-///
-/// If the product is empty for a given segment ID `i`, `output[i] = 1`.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentProd.png" alt>
-/// </div>
-///
-/// For example:
-///
-/// ```
-/// c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
-/// tf.segment_prod(c, tf.constant([0, 0, 1]))
-/// # ==> [[4, 6, 6, 4],
-/// #      [5, 6, 7, 8]]
-/// ```
-///
-///
-/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
-///   first dimension.  Values should be sorted and can be repeated.
-///
-/// - Output output: Has same shape as data, except for dimension 0 which
-///   has size `k`, the number of segments.
-@inlinable
-public static func segmentProd<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  segmentIds: Tensor<Tindices>
-) -> Tensor<T> {
-  let op = TFE_Op("SegmentProd")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(segmentIds)
-  return op.execute(Int(1))
-}
-
-/// Computes the sum along segments of a tensor.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
-/// for an explanation of segments.
-///
-/// Computes a tensor such that
-/// \\(output_i = \sum_j data_j\\) where sum is over `j` such
-/// that `segment_ids[j] == i`.
-///
-/// If the sum is empty for a given segment ID `i`, `output[i] = 0`.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentSum.png" alt>
-/// </div>
-///
-/// For example:
-///
-/// ```
-/// c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
-/// tf.segment_sum(c, tf.constant([0, 0, 1]))
-/// # ==> [[5, 5, 5, 5],
-/// #      [5, 6, 7, 8]]
-/// ```
-///
-///
-/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
-///   first dimension.  Values should be sorted and can be repeated.
-///
-/// - Output output: Has same shape as data, except for dimension 0 which
-///   has size `k`, the number of segments.
-@inlinable
-public static func segmentSum<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  segmentIds: Tensor<Tindices>
-) -> Tensor<T> {
-  let op = TFE_Op("SegmentSum")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(segmentIds)
-  return op.execute(Int(1))
-}
-
-/// Selects elements from `x` or `y`, depending on `condition`.
-///
-/// The `x`, and `y` tensors must all have the same shape, and the
-/// output will also have that shape.
-///
-/// The `condition` tensor must be a scalar if `x` and `y` are scalars.
-/// If `x` and `y` are vectors or higher rank, then `condition` must be either a
-/// scalar, a vector with size matching the first dimension of `x`, or must have
-/// the same shape as `x`.
-///
-/// The `condition` tensor acts as a mask that chooses, based on the value at each
-/// element, whether the corresponding element / row in the output should be
-/// taken from `x` (if true) or `y` (if false).
-///
-/// If `condition` is a vector and `x` and `y` are higher rank matrices, then
-/// it chooses which row (outer dimension) to copy from `x` and `y`.
-/// If `condition` has the same shape as `x` and `y`, then it chooses which
-/// element to copy from `x` and `y`.
-///
-/// For example:
-///
-/// ```python
-/// # 'condition' tensor is [[True,  False]
-/// #                        [False, True]]
-/// # 't' is [[1, 2],
-/// #         [3, 4]]
-/// # 'e' is [[5, 6],
-/// #         [7, 8]]
-/// select(condition, t, e)  # => [[1, 6], [7, 4]]
-///
-///
-/// # 'condition' tensor is [True, False]
-/// # 't' is [[1, 2],
-/// #         [3, 4]]
-/// # 'e' is [[5, 6],
-/// #         [7, 8]]
-/// select(condition, t, e) ==> [[1, 2],
-///                              [7, 8]]
-///
-/// ```
-///
-/// - Parameters:
-///   - t: = A `Tensor` which may have the same shape as `condition`.
-///     If `condition` is rank 1, `x` may have higher rank,
-///     but its first dimension must match the size of `condition`.
-///   - e: = A `Tensor` with the same type and shape as `x`.
-///
-/// - Output output: = A `Tensor` with the same type and shape as `x` and `y`.
-@inlinable
-public static func select<T: TensorFlowScalar>(
-  condition: Tensor<Bool>,
-  t: Tensor<T>,
-  e: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Select")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(condition)
-  let _ = op.addInput(t)
-  let _ = op.addInput(e)
-  return op.execute(Int(1))
-}
-
-/// Computes the Eigen Decomposition of a batch of square self-adjoint matrices.
-///
-/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
-/// form square matrices, with the same constraints as the single matrix
-/// SelfAdjointEig.
-///
-/// The result is a [..., M+1, M] matrix with [..., 0,:] containing the
-/// eigenvalues, and subsequent [...,1:, :] containing the eigenvectors. The eigenvalues
-/// are sorted in non-decreasing order.
-///
-/// - Parameter input: Shape is `[..., M, M]`.
-///
-/// - Output output: Shape is `[..., M+1, M]`.
-@inlinable
-public static func selfAdjointEig<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("SelfAdjointEig")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Computes the eigen decomposition of one or more square self-adjoint matrices.
-///
-/// Computes the eigenvalues and (optionally) eigenvectors of each inner matrix in
-/// `input` such that `input[..., :, :] = v[..., :, :] * diag(e[..., :])`. The eigenvalues
-/// are sorted in non-decreasing order.
-///
-/// ```python
-/// # a is a tensor.
-/// # e is a tensor of eigenvalues.
-/// # v is a tensor of eigenvectors.
-/// e, v = self_adjoint_eig(a)
-/// e = self_adjoint_eig(a, compute_v=False)
-/// ```
-///
-/// - Parameter input: `Tensor` input of shape `[N, N]`.
-///
-/// - Attr compute_v: If `True` then eigenvectors will be computed and returned in `v`.
-///   Otherwise, only the eigenvalues will be computed.
-///
-/// - Outputs:
-///   - e: Eigenvalues. Shape is `[N]`.
-///   - v: Eigenvectors. Shape is `[N, N]`.
-@inlinable
-public static func selfAdjointEigV2<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  computeV: Bool = true
-) -> (e: Tensor<T>, v: Tensor<T>) {
-  let op = TFE_Op("SelfAdjointEigV2")
-  op.setAttr("compute_v", computeV)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Computes scaled exponential linear: `scale * alpha * (exp(features) - 1)`
-///
-/// if < 0, `scale * features` otherwise.
-///
-/// To be used together with
-/// `initializer = tf.variance_scaling_initializer(factor=1.0, mode='FAN_IN')`.
-/// For correct dropout, use `tf.contrib.nn.alpha_dropout`.
-///
-/// See [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)
-@inlinable
-public static func selu<T: FloatingPoint & TensorFlowScalar>(
-  features: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Selu")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(features)
-  return op.execute(Int(1))
-}
-
-/// Computes gradients for the scaled exponential linear (Selu) operation.
-///
-/// - Parameters:
-///   - gradients: The backpropagated gradients to the corresponding Selu operation.
-///   - outputs: The outputs of the corresponding Selu operation.
-///
-/// - Output backprops: The gradients: `gradients * (outputs + scale * alpha)`
-///   if outputs < 0, `scale * gradients` otherwise.
-@inlinable
-public static func seluGrad<T: FloatingPoint & TensorFlowScalar>(
-  gradients: Tensor<T>,
-  outputs: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("SeluGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(gradients)
-  let _ = op.addInput(outputs)
-  return op.execute(Int(1))
-}
-
-/// Performs gradient updates of embedding tables.
-///
-/// - Parameters:
-///   - inputs: A TensorList of gradients with which to update embedding tables.
-///     This argument has the same length and shapes as the return value of
-///     RecvTPUEmbeddingActivations, but contains gradients of the model's loss
-///     with respect to the embedding activations. The embedding tables are updated
-///     from these gradients via the optimizer specified in the TPU embedding
-///     configuration given to tpu.initialize_system.
-///   - learning_rates: A TensorList of float32 scalars, one for each dynamic learning
-///     rate tag: see the comments in
-///     //third_party/tensorflow/core/protobuf/tpu/optimization_parameters.proto.
-///     Multiple tables can share the same dynamic learning rate tag as specified
-///     in the configuration. If the learning rates for all tables are constant,
-///     this list should be empty.
-///
-/// - Attr config: Serialized TPUEmbeddingConfiguration proto.
-@inlinable
-public static func sendTPUEmbeddingGradients(
-  inputs: [Tensor<Float>],
-  learningRates: [Tensor<Float>],
-  config: String
-) {
-  let op = TFE_Op("SendTPUEmbeddingGradients")
-  op.setAttr("N", inputs.count)
-  op.setAttr("NN", learningRates.count)
-  op.setAttr("config", config)
-  let _ = op.addInputList(inputs)
-  let _ = op.addInputList(learningRates)
-  op.execute()
-}
-
-/// Converts the given `resource_handle` representing an iterator to a variant tensor.
-///
-/// - Parameter resource_handle: A handle to an iterator resource.
-///
-/// - Output serialized: A variant tensor storing the state of the iterator contained in the
-///   resource.
-@inlinable
-public static func serializeIterator(
-  resourceHandle: ResourceHandle
-) -> VariantHandle {
-  let op = TFE_Op("SerializeIterator")
-  let _ = op.addInput(resourceHandle)
-  return op.execute(Int(1))
-}
-
-/// Serialize an `N`-minibatch `SparseTensor` into an `[N, 3]` `Tensor` object.
-///
-/// The `SparseTensor` must have rank `R` greater than 1, and the first dimension
-/// is treated as the minibatch dimension.  Elements of the `SparseTensor`
-/// must be sorted in increasing order of this first dimension.  The serialized
-/// `SparseTensor` objects going into each row of `serialized_sparse` will have
-/// rank `R-1`.
-///
-/// The minibatch size `N` is extracted from `sparse_shape[0]`.
-///
-/// - Parameters:
-///   - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
-///   - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
-///   - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
-///
-/// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
-///   (default) and `variant`.
-@inlinable
-public static func serializeManySparse<
-    T: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  sparseIndices: Tensor<Int64>,
-  sparseValues: Tensor<T>,
-  sparseShape: Tensor<Int64>
-) -> Tensor<OutType> {
-  let op = TFE_Op("SerializeManySparse")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(sparseIndices)
-  let _ = op.addInput(sparseValues)
-  let _ = op.addInput(sparseShape)
-  return op.execute(Int(1))
-}
-
-/// Serialize an `N`-minibatch `SparseTensor` into an `[N, 3]` `Tensor` object.
-///
-/// The `SparseTensor` must have rank `R` greater than 1, and the first dimension
-/// is treated as the minibatch dimension.  Elements of the `SparseTensor`
-/// must be sorted in increasing order of this first dimension.  The serialized
-/// `SparseTensor` objects going into each row of `serialized_sparse` will have
-/// rank `R-1`.
-///
-/// The minibatch size `N` is extracted from `sparse_shape[0]`.
-///
-/// - Parameters:
-///   - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
-///   - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
-///   - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
-///
-/// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
-///   (default) and `variant`.
-@inlinable
-public static func serializeManySparse<T: TensorFlowScalar>(
-  sparseIndices: Tensor<Int64>,
-  sparseValues: Tensor<T>,
-  sparseShape: Tensor<Int64>
-) -> StringTensor {
-  let op = TFE_Op("SerializeManySparse")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_type", TensorDataType(TF_STRING))
-  let _ = op.addInput(sparseIndices)
-  let _ = op.addInput(sparseValues)
-  let _ = op.addInput(sparseShape)
-  return op.execute(Int(1))
-}
-
-/// Serialize a `SparseTensor` into a `[3]` `Tensor` object.
-///
-/// - Parameters:
-///   - sparse_indices: 2-D.  The `indices` of the `SparseTensor`.
-///   - sparse_values: 1-D.  The `values` of the `SparseTensor`.
-///   - sparse_shape: 1-D.  The `shape` of the `SparseTensor`.
-///
-/// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
-///   (default) and `variant`.
-@inlinable
-public static func serializeSparse<
-    T: TensorFlowScalar,
-    OutType: TensorFlowScalar
->(
-  sparseIndices: Tensor<Int64>,
-  sparseValues: Tensor<T>,
-  sparseShape: Tensor<Int64>
-) -> Tensor<OutType> {
-  let op = TFE_Op("SerializeSparse")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(sparseIndices)
-  let _ = op.addInput(sparseValues)
-  let _ = op.addInput(sparseShape)
-  return op.execute(Int(1))
-}
-
-/// Serialize a `SparseTensor` into a `[3]` `Tensor` object.
-///
-/// - Parameters:
-///   - sparse_indices: 2-D.  The `indices` of the `SparseTensor`.
-///   - sparse_values: 1-D.  The `values` of the `SparseTensor`.
-///   - sparse_shape: 1-D.  The `shape` of the `SparseTensor`.
-///
-/// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
-///   (default) and `variant`.
-@inlinable
-public static func serializeSparse<T: TensorFlowScalar>(
-  sparseIndices: Tensor<Int64>,
-  sparseValues: Tensor<T>,
-  sparseShape: Tensor<Int64>
-) -> StringTensor {
-  let op = TFE_Op("SerializeSparse")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_type", TensorDataType(TF_STRING))
-  let _ = op.addInput(sparseIndices)
-  let _ = op.addInput(sparseValues)
-  let _ = op.addInput(sparseShape)
-  return op.execute(Int(1))
-}
-
-/// Transforms a Tensor into a serialized TensorProto proto.
-///
-/// - Parameter tensor: A Tensor of type `T`.
-///
-/// - Attr T: The type of the input tensor.
-///
-/// - Output serialized: A serialized TensorProto proto of the input tensor.
-@inlinable
-public static func serializeTensor<T: TensorFlowScalar>(
-  _ tensor: Tensor<T>
-) -> StringTensor {
-  let op = TFE_Op("SerializeTensor")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(tensor)
-  return op.execute(Int(1))
-}
-
-/// Number of unique elements along last dimension of input `set`.
-///
-/// Input `set` is a `SparseTensor` represented by `set_indices`, `set_values`,
-/// and `set_shape`. The last dimension contains values in a set, duplicates are
-/// allowed but ignored.
-///
-/// If `validate_indices` is `True`, this op validates the order and range of `set`
-/// indices.
-///
-/// - Parameters:
-///   - set_indices: 2D `Tensor`, indices of a `SparseTensor`.
-///   - set_values: 1D `Tensor`, values of a `SparseTensor`.
-///   - set_shape: 1D `Tensor`, shape of a `SparseTensor`.
-///
-/// - Output size: For `set` ranked `n`, this is a `Tensor` with rank `n-1`, and the same 1st
-///   `n-1` dimensions as `set`. Each value is the number of unique elements in
-///   the corresponding `[0...n-1]` dimension of `set`.
-@inlinable
-public static func setSize<T: BinaryInteger & TensorFlowScalar>(
-  setIndices: Tensor<Int64>,
-  setValues: Tensor<T>,
-  setShape: Tensor<Int64>,
-  validateIndices: Bool = true
-) -> Tensor<Int32> {
-  let op = TFE_Op("SetSize")
-  op.setAttr("validate_indices", validateIndices)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(setIndices)
-  let _ = op.addInput(setValues)
-  let _ = op.addInput(setShape)
-  return op.execute(Int(1))
-}
-
-/// Number of unique elements along last dimension of input `set`.
-///
-/// Input `set` is a `SparseTensor` represented by `set_indices`, `set_values`,
-/// and `set_shape`. The last dimension contains values in a set, duplicates are
-/// allowed but ignored.
-///
-/// If `validate_indices` is `True`, this op validates the order and range of `set`
-/// indices.
-///
-/// - Parameters:
-///   - set_indices: 2D `Tensor`, indices of a `SparseTensor`.
-///   - set_values: 1D `Tensor`, values of a `SparseTensor`.
-///   - set_shape: 1D `Tensor`, shape of a `SparseTensor`.
-///
-/// - Output size: For `set` ranked `n`, this is a `Tensor` with rank `n-1`, and the same 1st
-///   `n-1` dimensions as `set`. Each value is the number of unique elements in
-///   the corresponding `[0...n-1]` dimension of `set`.
-@inlinable
-public static func setSize(
-  setIndices: Tensor<Int64>,
-  setValues: StringTensor,
-  setShape: Tensor<Int64>,
-  validateIndices: Bool = true
-) -> Tensor<Int32> {
-  let op = TFE_Op("SetSize")
-  op.setAttr("validate_indices", validateIndices)
-  op.setAttr("T", TensorDataType(TF_STRING))
-  let _ = op.addInput(setIndices)
-  let _ = op.addInput(setValues)
-  let _ = op.addInput(setShape)
-  return op.execute(Int(1))
-}
-
-/// Returns the shape of a tensor.
-///
-/// This operation returns a 1-D integer tensor representing the shape of `input`.
-///
-/// For example:
-///
-/// ```
-/// # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
-/// shape(t) ==> [2, 2, 3]
-/// ```
-@inlinable
-public static func shape<
-    T: TensorFlowScalar,
-    OutType: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>
-) -> Tensor<OutType> {
-  let op = TFE_Op("Shape")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Returns shape of tensors.
-///
-/// This operation returns N 1-D integer tensors representing shape of `input[i]s`.
-@inlinable
-public static func shapeN<
-    T: TensorFlowScalar,
-    OutType: BinaryInteger & TensorFlowScalar
->(
-  _ input: [Tensor<T>]
-) -> [Tensor<OutType>] {
-  let op = TFE_Op("ShapeN")
-  op.setAttr("N", input.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInputList(input)
-  return op.execute(Int(input.count))
-}
-
-/// Creates a `Dataset` that includes only 1/`num_shards` of this dataset.
-///
-/// - Parameters:
-///   - num_shards: An integer representing the number of shards operating in parallel.
-///   - index: An integer representing the current worker index.
-@inlinable
-public static func shardDataset(
-  inputDataset: VariantHandle,
-  numShards: Tensor<Int64>,
-  index: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ShardDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(numShards)
-  let _ = op.addInput(index)
-  return op.execute(Int(1))
-}
-
-/// Generate a sharded filename. The filename is printf formatted as
-///
-///    %s-%05d-of-%05d, basename, shard, num_shards.
-@inlinable
-public static func shardedFilename(
-  basename: StringTensor,
-  shard: Tensor<Int32>,
-  numShards: Tensor<Int32>
-) -> StringTensor {
-  let op = TFE_Op("ShardedFilename")
-  let _ = op.addInput(basename)
-  let _ = op.addInput(shard)
-  let _ = op.addInput(numShards)
-  return op.execute(Int(1))
-}
-
-/// Generate a glob pattern matching all sharded file names.
-@inlinable
-public static func shardedFilespec(
-  basename: StringTensor,
-  numShards: Tensor<Int32>
-) -> StringTensor {
-  let op = TFE_Op("ShardedFilespec")
-  let _ = op.addInput(basename)
-  let _ = op.addInput(numShards)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that shuffles and repeats elements from `input_dataset`
-///
-/// pseudorandomly.
-///
-/// - Parameters:
-///   - buffer_size: The number of output elements to buffer in an iterator over
-///     this dataset. Compare with the `min_after_dequeue` attr when creating a
-///     `RandomShuffleQueue`.
-///   - seed: A scalar seed for the random number generator. If either `seed` or
-///     `seed2` is set to be non-zero, the random number generator is seeded
-///     by the given seed.  Otherwise, a random seed is used.
-///   - seed2: A second scalar seed to avoid seed collision.
-///   - count: A scalar representing the number of times the underlying dataset
-///     should be repeated. The default is `-1`, which results in infinite repetition.
-@inlinable
-public static func shuffleAndRepeatDataset(
-  inputDataset: VariantHandle,
-  bufferSize: Tensor<Int64>,
-  seed: Tensor<Int64>,
-  seed2: Tensor<Int64>,
-  count: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ShuffleAndRepeatDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(bufferSize)
-  let _ = op.addInput(seed)
-  let _ = op.addInput(seed2)
-  let _ = op.addInput(count)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that shuffles elements from `input_dataset` pseudorandomly.
-///
-/// - Parameters:
-///   - buffer_size: The number of output elements to buffer in an iterator over
-///     this dataset. Compare with the `min_after_dequeue` attr when creating a
-///     `RandomShuffleQueue`.
-///   - seed: A scalar seed for the random number generator. If either `seed` or
-///     `seed2` is set to be non-zero, the random number generator is seeded
-///     by the given seed.  Otherwise, a random seed is used.
-///   - seed2: A second scalar seed to avoid seed collision.
-///
-/// - Attr reshuffle_each_iteration: If true, each iterator over this dataset will be given
-///   a different pseudorandomly generated seed, based on a sequence seeded by the
-///   `seed` and `seed2` inputs. If false, each iterator will be given the same
-///   seed, and repeated iteration over this dataset will yield the exact same
-///   sequence of results.
-@inlinable
-public static func shuffleDataset(
-  inputDataset: VariantHandle,
-  bufferSize: Tensor<Int64>,
-  seed: Tensor<Int64>,
-  seed2: Tensor<Int64>,
-  reshuffleEachIteration: Bool = true,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ShuffleDataset")
-  op.setAttr("reshuffle_each_iteration", reshuffleEachIteration)
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(bufferSize)
-  let _ = op.addInput(seed)
-  let _ = op.addInput(seed2)
-  return op.execute(Int(1))
-}
-
-/// Shuts down a running distributed TPU system.
-///
-/// The op returns an error if no system is running.
-@inlinable
-public static func shutdownDistributedTPU(
-) {
-  let op = TFE_Op("ShutdownDistributedTPU")
-  
-  op.execute()
-}
-
-/// Computes sigmoid of `x` element-wise.
-///
-/// Specifically, `y = 1 / (1 + exp(-x))`.
-@inlinable
-public static func sigmoid<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Sigmoid")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient of the sigmoid of `x` wrt its input.
-///
-/// Specifically, `grad = dy * y * (1 - y)`, where `y = sigmoid(x)`, and
-/// `dy` is the corresponding input gradient.
-@inlinable
-public static func sigmoidGrad<T: FloatingPoint & TensorFlowScalar>(
-  _ y: Tensor<T>,
-  dy: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("SigmoidGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(y)
-  let _ = op.addInput(dy)
-  return op.execute(Int(1))
-}
-
-/// Returns an element-wise indication of the sign of a number.
-///
-/// `y = sign(x) = -1` if `x < 0`; 0 if `x == 0`; 1 if `x > 0`.
-///
-/// For complex numbers, `y = sign(x) = x / |x|` if `x != 0`, otherwise `y = 0`.
-@inlinable
-public static func sign<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Sign")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func simple(
-  _ a: Tensor<Int32>
-) -> Tensor<Float> {
-  let op = TFE_Op("Simple")
-  let _ = op.addInput(a)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func simpleStruct(
-  nA: Int64
-) -> [Tensor<Int32>] {
-  let op = TFE_Op("SimpleStruct")
-  op.setAttr("n_a", nA)
-  return op.execute(Int(nA))
-}
-
-/// Computes sin of x element-wise.
-@inlinable
-public static func sin<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Sin")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes hyperbolic sine of x element-wise.
-@inlinable
-public static func sinh<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Sinh")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns the size of a tensor.
-///
-/// This operation returns an integer representing the number of elements in
-/// `input`.
-///
-/// For example:
-///
-/// ```
-/// # 't' is [[[1, 1,, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]
-/// size(t) ==> 12
-/// ```
-@inlinable
-public static func size<
-    T: TensorFlowScalar,
-    OutType: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>
-) -> Tensor<OutType> {
-  let op = TFE_Op("Size")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that skips `count` elements from the `input_dataset`.
-///
-/// - Parameter count: A scalar representing the number of elements from the `input_dataset`
-///   that should be skipped.  If count is -1, skips everything.
-@inlinable
-public static func skipDataset(
-  inputDataset: VariantHandle,
-  count: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("SkipDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(count)
-  return op.execute(Int(1))
-}
-
-/// Parses a text file and creates a batch of examples.
-///
-/// - Attrs:
-///   - filename: The corpus's text file name.
-///   - batch_size: The size of produced batch.
-///   - window_size: The number of words to predict to the left and right of the target.
-///   - min_count: The minimum number of word occurrences for it to be included in the
-///     vocabulary.
-///   - subsample: Threshold for word occurrence. Words that appear with higher
-///     frequency will be randomly down-sampled. Set to 0 to disable.
-///
-/// - Outputs:
-///   - vocab_word: A vector of words in the corpus.
-///   - vocab_freq: Frequencies of words. Sorted in the non-ascending order.
-///   - words_per_epoch: Number of words per epoch in the data file.
-///   - current_epoch: The current epoch number.
-///   - total_words_processed: The total number of words processed so far.
-///   - examples: A vector of word ids.
-///   - labels: A vector of word ids.
-@inlinable
-public static func skipgram(
-  filename: String,
-  batchSize: Int64,
-  windowSize: Int64 = 5,
-  minCount: Int64 = 5,
-  subsample: Double = 0.001
-) -> (vocabWord: StringTensor, vocabFreq: Tensor<Int32>, wordsPerEpoch: Tensor<Int64>, currentEpoch: Tensor<Int32>, totalWordsProcessed: Tensor<Int64>, examples: Tensor<Int32>, labels: Tensor<Int32>) {
-  let op = TFE_Op("Skipgram")
-  op.setAttr("filename", filename)
-  op.setAttr("batch_size", batchSize)
-  op.setAttr("window_size", windowSize)
-  op.setAttr("min_count", minCount)
-  op.setAttr("subsample", subsample)
-  return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
-}
-
-/// Return a slice from 'input'.
-///
-/// The output tensor is a tensor with dimensions described by 'size'
-/// whose values are extracted from 'input' starting at the offsets in
-/// 'begin'.
-///
-/// *Requirements*:
-///   0 <= begin[i] <= begin[i] + size[i] <= Di  for i in [0, n)
-///
-/// - Parameters:
-///   - begin: begin[i] specifies the offset into the 'i'th dimension of
-///     'input' to slice from.
-///   - size: size[i] specifies the number of elements of the 'i'th dimension
-///     of 'input' to slice. If size[i] is -1, all remaining elements in dimension
-///     i are included in the slice (i.e. this is equivalent to setting
-///     size[i] = input.dim_size(i) - begin[i]).
-@inlinable
-public static func slice<
-    T: TensorFlowScalar,
-    Index: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  begin: Tensor<Index>,
-  size: Tensor<Index>
-) -> Tensor<T> {
-  let op = TFE_Op("Slice")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Index", Index.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(begin)
-  let _ = op.addInput(size)
-  return op.execute(Int(1))
-}
-
-/// Returns a copy of the input tensor.
-@inlinable
-public static func snapshot<T: TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Snapshot")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Computes softmax activations.
-///
-/// For each batch `i` and class `j` we have
-///
-///     $$softmax[i, j] = exp(logits[i, j]) / sum_j(exp(logits[i, j]))$$
-///
-/// - Parameter logits: 2-D with shape `[batch_size, num_classes]`.
-///
-/// - Output softmax: Same shape as `logits`.
-@inlinable
-public static func softmax<T: FloatingPoint & TensorFlowScalar>(
-  logits: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Softmax")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(logits)
-  return op.execute(Int(1))
-}
-
-/// Computes softmax cross entropy cost and gradients to backpropagate.
-///
-/// Inputs are the logits, not probabilities.
-///
-/// - Parameters:
-///   - features: batch_size x num_classes matrix
-///   - labels: batch_size x num_classes matrix
-///     The caller must ensure that each batch of labels represents a valid
-///     probability distribution.
-///
-/// - Outputs:
-///   - loss: Per example loss (batch_size vector).
-///   - backprop: backpropagated gradients (batch_size x num_classes matrix).
-@inlinable
-public static func softmaxCrossEntropyWithLogits<T: FloatingPoint & TensorFlowScalar>(
-  features: Tensor<T>,
-  labels: Tensor<T>
-) -> (loss: Tensor<T>, backprop: Tensor<T>) {
-  let op = TFE_Op("SoftmaxCrossEntropyWithLogits")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(features)
-  let _ = op.addInput(labels)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Computes softplus: `log(exp(features) + 1)`.
-@inlinable
-public static func softplus<T: FloatingPoint & TensorFlowScalar>(
-  features: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Softplus")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(features)
-  return op.execute(Int(1))
-}
-
-/// Computes softplus gradients for a softplus operation.
-///
-/// - Parameters:
-///   - gradients: The backpropagated gradients to the corresponding softplus operation.
-///   - features: The features passed as input to the corresponding softplus operation.
-///
-/// - Output backprops: The gradients: `gradients / (1 + exp(-features))`.
-@inlinable
-public static func softplusGrad<T: FloatingPoint & TensorFlowScalar>(
-  gradients: Tensor<T>,
-  features: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("SoftplusGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(gradients)
-  let _ = op.addInput(features)
-  return op.execute(Int(1))
-}
-
-/// Computes softsign: `features / (abs(features) + 1)`.
-@inlinable
-public static func softsign<T: FloatingPoint & TensorFlowScalar>(
-  features: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Softsign")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(features)
-  return op.execute(Int(1))
-}
-
-/// Computes softsign gradients for a softsign operation.
-///
-/// - Parameters:
-///   - gradients: The backpropagated gradients to the corresponding softsign operation.
-///   - features: The features passed as input to the corresponding softsign operation.
-///
-/// - Output backprops: The gradients: `gradients / (1 + abs(features)) ** 2`.
-@inlinable
-public static func softsignGrad<T: FloatingPoint & TensorFlowScalar>(
-  gradients: Tensor<T>,
-  features: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("SoftsignGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(gradients)
-  let _ = op.addInput(features)
-  return op.execute(Int(1))
-}
-
-/// SpaceToBatch for 4-D tensors of type T.
-///
-/// This is a legacy version of the more general SpaceToBatchND.
-///
-/// Zero-pads and then rearranges (permutes) blocks of spatial data into batch.
-/// More specifically, this op outputs a copy of the input tensor where values from
-/// the `height` and `width` dimensions are moved to the `batch` dimension. After
-/// the zero-padding, both `height` and `width` of the input must be divisible by the
-/// block size.
-///
-/// - Parameters:
-///   - input: 4-D with shape `[batch, height, width, depth]`.
-///   - paddings: 2-D tensor of non-negative integers with shape `[2, 2]`. It specifies
-///       the padding of the input with zeros across the spatial dimensions as follows:
-///
-///           paddings = [[pad_top, pad_bottom], [pad_left, pad_right]]
-///
-///       The effective spatial dimensions of the zero-padded input tensor will be:
-///
-///           height_pad = pad_top + height + pad_bottom
-///           width_pad = pad_left + width + pad_right
-///
-///     The attr `block_size` must be greater than one. It indicates the block size.
-///
-///       * Non-overlapping blocks of size `block_size x block size` in the height and
-///         width dimensions are rearranged into the batch dimension at each location.
-///       * The batch of the output tensor is `batch * block_size * block_size`.
-///       * Both height_pad and width_pad must be divisible by block_size.
-///
-///     The shape of the output will be:
-///
-///         [batch*block_size*block_size, height_pad/block_size, width_pad/block_size,
-///          depth]
-///
-///     Some examples:
-///
-///     (1) For the following input of shape `[1, 2, 2, 1]` and block_size of 2:
-///
-///     ```
-///     x = [[[[1], [2]], [[3], [4]]]]
-///     ```
-///
-///     The output tensor has shape `[4, 1, 1, 1]` and value:
-///
-///     ```
-///     [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
-///     ```
-///
-///     (2) For the following input of shape `[1, 2, 2, 3]` and block_size of 2:
-///
-///     ```
-///     x = [[[[1, 2, 3], [4, 5, 6]],
-///           [[7, 8, 9], [10, 11, 12]]]]
-///     ```
-///
-///     The output tensor has shape `[4, 1, 1, 3]` and value:
-///
-///     ```
-///     [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
-///     ```
-///
-///     (3) For the following input of shape `[1, 4, 4, 1]` and block_size of 2:
-///
-///     ```
-///     x = [[[[1],   [2],  [3],  [4]],
-///           [[5],   [6],  [7],  [8]],
-///           [[9],  [10], [11],  [12]],
-///           [[13], [14], [15],  [16]]]]
-///     ```
-///
-///     The output tensor has shape `[4, 2, 2, 1]` and value:
-///
-///     ```
-///     x = [[[[1], [3]], [[9], [11]]],
-///          [[[2], [4]], [[10], [12]]],
-///          [[[5], [7]], [[13], [15]]],
-///          [[[6], [8]], [[14], [16]]]]
-///     ```
-///
-///     (4) For the following input of shape `[2, 2, 4, 1]` and block_size of 2:
-///
-///     ```
-///     x = [[[[1],   [2],  [3],  [4]],
-///           [[5],   [6],  [7],  [8]]],
-///          [[[9],  [10], [11],  [12]],
-///           [[13], [14], [15],  [16]]]]
-///     ```
-///
-///     The output tensor has shape `[8, 1, 2, 1]` and value:
-///
-///     ```
-///     x = [[[[1], [3]]], [[[9], [11]]], [[[2], [4]]], [[[10], [12]]],
-///          [[[5], [7]]], [[[13], [15]]], [[[6], [8]]], [[[14], [16]]]]
-///     ```
-///
-///     Among others, this operation is useful for reducing atrous convolution into
-///     regular convolution.
-@inlinable
-public static func spaceToBatch<
-    T: TensorFlowScalar,
-    Tpaddings: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  paddings: Tensor<Tpaddings>,
-  blockSize: Int64
-) -> Tensor<T> {
-  let op = TFE_Op("SpaceToBatch")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tpaddings", Tpaddings.tensorFlowDataType)
-  op.setAttr("block_size", blockSize)
-  let _ = op.addInput(input)
-  let _ = op.addInput(paddings)
-  return op.execute(Int(1))
-}
-
-/// SpaceToBatch for N-D tensors of type T.
-///
-/// This operation divides "spatial" dimensions `[1, ..., M]` of the input into a
-/// grid of blocks of shape `block_shape`, and interleaves these blocks with the
-/// "batch" dimension (0) such that in the output, the spatial dimensions
-/// `[1, ..., M]` correspond to the position within the grid, and the batch
-/// dimension combines both the position within a spatial block and the original
-/// batch position.  Prior to division into blocks, the spatial dimensions of the
-/// input are optionally zero padded according to `paddings`.  See below for a
-/// precise description.
-///
-/// - Parameters:
-///   - input: N-D with shape `input_shape = [batch] + spatial_shape + remaining_shape`,
-///     where spatial_shape has `M` dimensions.
-///   - block_shape: 1-D with shape `[M]`, all values must be >= 1.
-///   - paddings: 2-D with shape `[M, 2]`, all values must be >= 0.
-///       `paddings[i] = [pad_start, pad_end]` specifies the padding for input dimension
-///       `i + 1`, which corresponds to spatial dimension `i`.  It is required that
-///       `block_shape[i]` divides `input_shape[i + 1] + pad_start + pad_end`.
-///
-///     This operation is equivalent to the following steps:
-///
-///     1. Zero-pad the start and end of dimensions `[1, ..., M]` of the
-///        input according to `paddings` to produce `padded` of shape `padded_shape`.
-///
-///     2. Reshape `padded` to `reshaped_padded` of shape:
-///
-///          [batch] +
-///          [padded_shape[1] / block_shape[0],
-///            block_shape[0],
-///           ...,
-///           padded_shape[M] / block_shape[M-1],
-///           block_shape[M-1]] +
-///          remaining_shape
-///
-///     3. Permute dimensions of `reshaped_padded` to produce
-///        `permuted_reshaped_padded` of shape:
-///
-///          block_shape +
-///          [batch] +
-///          [padded_shape[1] / block_shape[0],
-///           ...,
-///           padded_shape[M] / block_shape[M-1]] +
-///          remaining_shape
-///
-///     4. Reshape `permuted_reshaped_padded` to flatten `block_shape` into the batch
-///        dimension, producing an output tensor of shape:
-///
-///          [batch * prod(block_shape)] +
-///          [padded_shape[1] / block_shape[0],
-///           ...,
-///           padded_shape[M] / block_shape[M-1]] +
-///          remaining_shape
-///
-///     Some examples:
-///
-///     (1) For the following input of shape `[1, 2, 2, 1]`, `block_shape = [2, 2]`, and
-///         `paddings = [[0, 0], [0, 0]]`:
-///
-///     ```
-///     x = [[[[1], [2]], [[3], [4]]]]
-///     ```
-///
-///     The output tensor has shape `[4, 1, 1, 1]` and value:
-///
-///     ```
-///     [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
-///     ```
-///
-///     (2) For the following input of shape `[1, 2, 2, 3]`, `block_shape = [2, 2]`, and
-///         `paddings = [[0, 0], [0, 0]]`:
-///
-///     ```
-///     x = [[[[1, 2, 3], [4, 5, 6]],
-///           [[7, 8, 9], [10, 11, 12]]]]
-///     ```
-///
-///     The output tensor has shape `[4, 1, 1, 3]` and value:
-///
-///     ```
-///     [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
-///     ```
-///
-///     (3) For the following input of shape `[1, 4, 4, 1]`, `block_shape = [2, 2]`, and
-///         `paddings = [[0, 0], [0, 0]]`:
-///
-///     ```
-///     x = [[[[1],   [2],  [3],  [4]],
-///           [[5],   [6],  [7],  [8]],
-///           [[9],  [10], [11],  [12]],
-///           [[13], [14], [15],  [16]]]]
-///     ```
-///
-///     The output tensor has shape `[4, 2, 2, 1]` and value:
-///
-///     ```
-///     x = [[[[1], [3]], [[9], [11]]],
-///          [[[2], [4]], [[10], [12]]],
-///          [[[5], [7]], [[13], [15]]],
-///          [[[6], [8]], [[14], [16]]]]
-///     ```
-///
-///     (4) For the following input of shape `[2, 2, 4, 1]`, block_shape = `[2, 2]`, and
-///         paddings = `[[0, 0], [2, 0]]`:
-///
-///     ```
-///     x = [[[[1],   [2],  [3],  [4]],
-///           [[5],   [6],  [7],  [8]]],
-///          [[[9],  [10], [11],  [12]],
-///           [[13], [14], [15],  [16]]]]
-///     ```
-///
-///     The output tensor has shape `[8, 1, 3, 1]` and value:
-///
-///     ```
-///     x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
-///          [[[0], [2], [4]]], [[[0], [10], [12]]],
-///          [[[0], [5], [7]]], [[[0], [13], [15]]],
-///          [[[0], [6], [8]]], [[[0], [14], [16]]]]
-///     ```
-///
-///     Among others, this operation is useful for reducing atrous convolution into
-///     regular convolution.
-@inlinable
-public static func spaceToBatchND<
-    T: TensorFlowScalar,
-    TblockShape: BinaryInteger & TensorFlowScalar,
-    Tpaddings: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  blockShape: Tensor<TblockShape>,
-  paddings: Tensor<Tpaddings>
-) -> Tensor<T> {
-  let op = TFE_Op("SpaceToBatchND")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tblock_shape", TblockShape.tensorFlowDataType)
-  op.setAttr("Tpaddings", Tpaddings.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(blockShape)
-  let _ = op.addInput(paddings)
-  return op.execute(Int(1))
-}
-
-/// SpaceToDepth for tensors of type T.
-///
-/// Rearranges blocks of spatial data, into depth. More specifically,
-/// this op outputs a copy of the input tensor where values from the `height`
-/// and `width` dimensions are moved to the `depth` dimension.
-/// The attr `block_size` indicates the input block size.
-///
-///   * Non-overlapping blocks of size `block_size x block size` are rearranged
-///     into depth at each location.
-///   * The depth of the output tensor is `block_size * block_size * input_depth`.
-///   * The Y, X coordinates within each block of the input become the high order
-///     component of the output channel index.
-///   * The input tensor's height and width must be divisible by block_size.
-///
-/// The `data_format` attr specifies the layout of the input and output tensors
-/// with the following options:
-///   "NHWC": `[ batch, height, width, channels ]`
-///   "NCHW": `[ batch, channels, height, width ]`
-///   "NCHW_VECT_C":
-///       `qint8 [ batch, channels / 4, height, width, 4 ]`
-///
-/// It is useful to consider the operation as transforming a 6-D Tensor.
-/// e.g. for data_format = NHWC,
-///      Each element in the input tensor can be specified via 6 coordinates,
-///      ordered by decreasing memory layout significance as:
-///      n,oY,bY,oX,bX,iC  (where n=batch index, oX, oY means X or Y coordinates
-///                         within the output image, bX, bY means coordinates
-///                         within the input block, iC means input channels).
-///      The output would be a transpose to the following layout:
-///      n,oY,oX,bY,bX,iC
-///
-/// This operation is useful for resizing the activations between convolutions
-/// (but keeping all data), e.g. instead of pooling. It is also useful for training
-/// purely convolutional models.
-///
-/// For example, given an input of shape `[1, 2, 2, 1]`, data_format = "NHWC" and
-/// block_size = 2:
-///
-/// ```
-/// x = [[[[1], [2]],
-///       [[3], [4]]]]
-/// ```
-///
-/// This operation will output a tensor of shape `[1, 1, 1, 4]`:
-///
-/// ```
-/// [[[[1, 2, 3, 4]]]]
-/// ```
-///
-/// Here, the input has a batch of 1 and each batch element has shape `[2, 2, 1]`,
-/// the corresponding output will have a single element (i.e. width and height are
-/// both 1) and will have a depth of 4 channels (1 * block_size * block_size).
-/// The output element shape is `[1, 1, 4]`.
-///
-/// For an input tensor with larger depth, here of shape `[1, 2, 2, 3]`, e.g.
-///
-/// ```
-/// x = [[[[1, 2, 3], [4, 5, 6]],
-///       [[7, 8, 9], [10, 11, 12]]]]
-/// ```
-///
-/// This operation, for block_size of 2, will return the following tensor of shape
-/// `[1, 1, 1, 12]`
-///
-/// ```
-/// [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
-/// ```
-///
-/// Similarly, for the following input of shape `[1 4 4 1]`, and a block size of 2:
-///
-/// ```
-/// x = [[[[1],   [2],  [5],  [6]],
-///       [[3],   [4],  [7],  [8]],
-///       [[9],  [10], [13],  [14]],
-///       [[11], [12], [15],  [16]]]]
-/// ```
-///
-/// the operator will return the following tensor of shape `[1 2 2 4]`:
-///
-/// ```
-/// x = [[[[1, 2, 3, 4],
-///        [5, 6, 7, 8]],
-///       [[9, 10, 11, 12],
-///        [13, 14, 15, 16]]]]
-/// ```
-///
-/// - Attr block_size: The size of the spatial block.
-@inlinable
-public static func spaceToDepth<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  blockSize: Int64,
-  dataFormat: DataFormat4 = .nhwc
-) -> Tensor<T> {
-  let op = TFE_Op("SpaceToDepth")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("block_size", blockSize)
-  op.setAttr("data_format", dataFormat.cName)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Adds two `SparseTensor` objects to produce another `SparseTensor`.
-///
-/// The input `SparseTensor` objects' indices are assumed ordered in standard
-/// lexicographic order.  If this is not the case, before this step run
-/// `SparseReorder` to restore index ordering.
-///
-/// By default, if two values sum to zero at some index, the output `SparseTensor`
-/// would still include that particular location in its index, storing a zero in the
-/// corresponding value slot.  To override this, callers can specify `thresh`,
-/// indicating that if the sum has a magnitude strictly smaller than `thresh`, its
-/// corresponding value and index would then not be included.  In particular,
-/// `thresh == 0` (default) means everything is kept and actual thresholding happens
-/// only for a positive value.
-///
-/// In the following shapes, `nnz` is the count after taking `thresh` into account.
-///
-/// - Parameters:
-///   - a_indices: 2-D.  The `indices` of the first `SparseTensor`, size `[nnz, ndims]` Matrix.
-///   - a_values: 1-D.  The `values` of the first `SparseTensor`, size `[nnz]` Vector.
-///   - a_shape: 1-D.  The `shape` of the first `SparseTensor`, size `[ndims]` Vector.
-///   - b_indices: 2-D.  The `indices` of the second `SparseTensor`, size `[nnz, ndims]` Matrix.
-///   - b_values: 1-D.  The `values` of the second `SparseTensor`, size `[nnz]` Vector.
-///   - b_shape: 1-D.  The `shape` of the second `SparseTensor`, size `[ndims]` Vector.
-///   - thresh: 0-D.  The magnitude threshold that determines if an output value/index
-///     pair takes space.
-@inlinable
-public static func sparseAdd<
-    T: Numeric & TensorFlowScalar,
-    Treal: Numeric & TensorFlowScalar
->(
-  aIndices: Tensor<Int64>,
-  aValues: Tensor<T>,
-  aShape: Tensor<Int64>,
-  bIndices: Tensor<Int64>,
-  bValues: Tensor<T>,
-  bShape: Tensor<Int64>,
-  thresh: Tensor<Treal>
-) -> (sumIndices: Tensor<Int64>, sumValues: Tensor<T>, sumShape: Tensor<Int64>) {
-  let op = TFE_Op("SparseAdd")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Treal", Treal.tensorFlowDataType)
-  let _ = op.addInput(aIndices)
-  let _ = op.addInput(aValues)
-  let _ = op.addInput(aShape)
-  let _ = op.addInput(bIndices)
-  let _ = op.addInput(bValues)
-  let _ = op.addInput(bShape)
-  let _ = op.addInput(thresh)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// The gradient operator for the SparseAdd op.
-///
-/// The SparseAdd op calculates A + B, where A, B, and the sum are all represented
-/// as `SparseTensor` objects.  This op takes in the upstream gradient w.r.t.
-/// non-empty values of the sum, and outputs the gradients w.r.t. the non-empty
-/// values of A and B.
-///
-/// - Parameters:
-///   - backprop_val_grad: 1-D with shape `[nnz(sum)]`.  The gradient with respect to
-///     the non-empty values of the sum.
-///   - a_indices: 2-D.  The `indices` of the `SparseTensor` A, size `[nnz(A), ndims]`.
-///   - b_indices: 2-D.  The `indices` of the `SparseTensor` B, size `[nnz(B), ndims]`.
-///   - sum_indices: 2-D.  The `indices` of the sum `SparseTensor`, size
-///     `[nnz(sum), ndims]`.
-///
-/// - Outputs:
-///   - a_val_grad: 1-D with shape `[nnz(A)]`. The gradient with respect to the
-///     non-empty values of A.
-///   - b_val_grad: 1-D with shape `[nnz(B)]`. The gradient with respect to the
-///     non-empty values of B.
-@inlinable
-public static func sparseAddGrad<T: Numeric & TensorFlowScalar>(
-  backpropValGrad: Tensor<T>,
-  aIndices: Tensor<Int64>,
-  bIndices: Tensor<Int64>,
-  sumIndices: Tensor<Int64>
-) -> (aValGrad: Tensor<T>, bValGrad: Tensor<T>) {
-  let op = TFE_Op("SparseAddGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(backpropValGrad)
-  let _ = op.addInput(aIndices)
-  let _ = op.addInput(bIndices)
-  let _ = op.addInput(sumIndices)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Concatenates a list of `SparseTensor` along the specified dimension.
-///
-/// Concatenation is with respect to the dense versions of these sparse tensors.
-/// It is assumed that each input is a `SparseTensor` whose elements are ordered
-/// along increasing dimension number.
-///
-/// All inputs' shapes must match, except for the concat dimension.  The
-/// `indices`, `values`, and `shapes` lists must have the same length.
-///
-/// The output shape is identical to the inputs', except along the concat
-/// dimension, where it is the sum of the inputs' sizes along that dimension.
-///
-/// The output elements will be resorted to preserve the sort order along
-/// increasing dimension number.
-///
-/// This op runs in `O(M log M)` time, where `M` is the total number of non-empty
-/// values across all inputs. This is due to the need for an internal sort in
-/// order to concatenate efficiently across an arbitrary dimension.
-///
-/// For example, if `concat_dim = 1` and the inputs are
-///
-///     sp_inputs[0]: shape = [2, 3]
-///     [0, 2]: "a"
-///     [1, 0]: "b"
-///     [1, 1]: "c"
-///
-///     sp_inputs[1]: shape = [2, 4]
-///     [0, 1]: "d"
-///     [0, 2]: "e"
-///
-/// then the output will be
-///
-///     shape = [2, 7]
-///     [0, 2]: "a"
-///     [0, 4]: "d"
-///     [0, 5]: "e"
-///     [1, 0]: "b"
-///     [1, 1]: "c"
-///
-/// Graphically this is equivalent to doing
-///
-///     [    a] concat [  d e  ] = [    a   d e  ]
-///     [b c  ]        [       ]   [b c          ]
-///
-/// - Parameters:
-///   - indices: 2-D.  Indices of each input `SparseTensor`.
-///   - values: 1-D.  Non-empty values of each `SparseTensor`.
-///   - shapes: 1-D.  Shapes of each `SparseTensor`.
-///
-/// - Attr concat_dim: Dimension to concatenate along. Must be in range [-rank, rank),
-///   where rank is the number of dimensions in each input `SparseTensor`.
-///
-/// - Outputs:
-///   - output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
-///   - output_values: 1-D.  Non-empty values of the concatenated `SparseTensor`.
-///   - output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
-@inlinable
-public static func sparseConcat<T: TensorFlowScalar>(
-  indices: [Tensor<Int64>],
-  _ values: [Tensor<T>],
-  shapes: [Tensor<Int64>],
-  concatDim: Int64
-) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, outputShape: Tensor<Int64>) {
-  let op = TFE_Op("SparseConcat")
-  op.setAttr("concat_dim", concatDim)
-  op.setAttr("N", indices.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInputList(indices)
-  let _ = op.addInputList(values)
-  let _ = op.addInputList(shapes)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Generates sparse cross from a list of sparse and dense tensors.
-///
-/// The op takes two lists, one of 2D `SparseTensor` and one of 2D `Tensor`, each
-/// representing features of one feature column. It outputs a 2D `SparseTensor` with
-/// the batchwise crosses of these features.
-///
-/// For example, if the inputs are
-///
-///     inputs[0]: SparseTensor with shape = [2, 2]
-///     [0, 0]: "a"
-///     [1, 0]: "b"
-///     [1, 1]: "c"
-///
-///     inputs[1]: SparseTensor with shape = [2, 1]
-///     [0, 0]: "d"
-///     [1, 0]: "e"
-///
-///     inputs[2]: Tensor [["f"], ["g"]]
-///
-/// then the output will be
-///
-///     shape = [2, 2]
-///     [0, 0]: "a_X_d_X_f"
-///     [1, 0]: "b_X_e_X_g"
-///     [1, 1]: "c_X_e_X_g"
-///
-/// if hashed_output=true then the output will be
-///
-///     shape = [2, 2]
-///     [0, 0]: FingerprintCat64(
-///                 Fingerprint64("f"), FingerprintCat64(
-///                     Fingerprint64("d"), Fingerprint64("a")))
-///     [1, 0]: FingerprintCat64(
-///                 Fingerprint64("g"), FingerprintCat64(
-///                     Fingerprint64("e"), Fingerprint64("b")))
-///     [1, 1]: FingerprintCat64(
-///                 Fingerprint64("g"), FingerprintCat64(
-///                     Fingerprint64("e"), Fingerprint64("c")))
-///
-/// - Parameters:
-///   - indices: 2-D.  Indices of each input `SparseTensor`.
-///   - values: 1-D.   values of each `SparseTensor`.
-///   - shapes: 1-D.   Shapes of each `SparseTensor`.
-///   - dense_inputs: 2-D.    Columns represented by dense `Tensor`.
-///
-/// - Attrs:
-///   - hashed_output: If true, returns the hash of the cross instead of the string.
-///     This will allow us avoiding string manipulations.
-///   - num_buckets: It is used if hashed_output is true.
-///     output = hashed_value%num_buckets if num_buckets > 0 else hashed_value.
-///   - hash_key: Specify the hash_key that will be used by the `FingerprintCat64`
-///     function to combine the crosses fingerprints.
-///
-/// - Outputs:
-///   - output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
-///   - output_values: 1-D.  Non-empty values of the concatenated or hashed
-///     `SparseTensor`.
-///   - output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
-@inlinable
-public static func sparseCross<
-    SparseTypes: TensorArrayProtocol,
-    DenseTypes: TensorArrayProtocol,
-    OutType: BinaryInteger & TensorFlowScalar
->(
-  indices: [Tensor<Int64>],
-  _ values: SparseTypes,
-  shapes: [Tensor<Int64>],
-  denseInputs: DenseTypes,
-  hashedOutput: Bool,
-  numBuckets: Int64,
-  hashKey: Int64,
-  internalType: TensorDataType
-) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<OutType>, outputShape: Tensor<Int64>) {
-  let op = TFE_Op("SparseCross")
-  op.setAttr("N", indices.count)
-  op.setAttr("hashed_output", hashedOutput)
-  op.setAttr("num_buckets", numBuckets)
-  op.setAttr("hash_key", hashKey)
-  op.setAttr("sparse_types", values._typeList)
-  op.setAttr("dense_types", denseInputs._typeList)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  op.setAttr("internal_type", internalType)
-  let _ = op.addInputList(indices)
-  let _ = op.addInputList(values)
-  let _ = op.addInputList(shapes)
-  let _ = op.addInputList(denseInputs)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Generates sparse cross from a list of sparse and dense tensors.
-///
-/// The op takes two lists, one of 2D `SparseTensor` and one of 2D `Tensor`, each
-/// representing features of one feature column. It outputs a 2D `SparseTensor` with
-/// the batchwise crosses of these features.
-///
-/// For example, if the inputs are
-///
-///     inputs[0]: SparseTensor with shape = [2, 2]
-///     [0, 0]: "a"
-///     [1, 0]: "b"
-///     [1, 1]: "c"
-///
-///     inputs[1]: SparseTensor with shape = [2, 1]
-///     [0, 0]: "d"
-///     [1, 0]: "e"
-///
-///     inputs[2]: Tensor [["f"], ["g"]]
-///
-/// then the output will be
-///
-///     shape = [2, 2]
-///     [0, 0]: "a_X_d_X_f"
-///     [1, 0]: "b_X_e_X_g"
-///     [1, 1]: "c_X_e_X_g"
-///
-/// if hashed_output=true then the output will be
-///
-///     shape = [2, 2]
-///     [0, 0]: FingerprintCat64(
-///                 Fingerprint64("f"), FingerprintCat64(
-///                     Fingerprint64("d"), Fingerprint64("a")))
-///     [1, 0]: FingerprintCat64(
-///                 Fingerprint64("g"), FingerprintCat64(
-///                     Fingerprint64("e"), Fingerprint64("b")))
-///     [1, 1]: FingerprintCat64(
-///                 Fingerprint64("g"), FingerprintCat64(
-///                     Fingerprint64("e"), Fingerprint64("c")))
-///
-/// - Parameters:
-///   - indices: 2-D.  Indices of each input `SparseTensor`.
-///   - values: 1-D.   values of each `SparseTensor`.
-///   - shapes: 1-D.   Shapes of each `SparseTensor`.
-///   - dense_inputs: 2-D.    Columns represented by dense `Tensor`.
-///
-/// - Attrs:
-///   - hashed_output: If true, returns the hash of the cross instead of the string.
-///     This will allow us avoiding string manipulations.
-///   - num_buckets: It is used if hashed_output is true.
-///     output = hashed_value%num_buckets if num_buckets > 0 else hashed_value.
-///   - hash_key: Specify the hash_key that will be used by the `FingerprintCat64`
-///     function to combine the crosses fingerprints.
-///
-/// - Outputs:
-///   - output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
-///   - output_values: 1-D.  Non-empty values of the concatenated or hashed
-///     `SparseTensor`.
-///   - output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
-@inlinable
-public static func sparseCross<
-    SparseTypes: TensorArrayProtocol,
-    DenseTypes: TensorArrayProtocol
->(
-  indices: [Tensor<Int64>],
-  _ values: SparseTypes,
-  shapes: [Tensor<Int64>],
-  denseInputs: DenseTypes,
-  hashedOutput: Bool,
-  numBuckets: Int64,
-  hashKey: Int64,
-  internalType: TensorDataType
-) -> (outputIndices: Tensor<Int64>, outputValues: StringTensor, outputShape: Tensor<Int64>) {
-  let op = TFE_Op("SparseCross")
-  op.setAttr("N", indices.count)
-  op.setAttr("hashed_output", hashedOutput)
-  op.setAttr("num_buckets", numBuckets)
-  op.setAttr("hash_key", hashKey)
-  op.setAttr("sparse_types", values._typeList)
-  op.setAttr("dense_types", denseInputs._typeList)
-  op.setAttr("out_type", TensorDataType(TF_STRING))
-  op.setAttr("internal_type", internalType)
-  let _ = op.addInputList(indices)
-  let _ = op.addInputList(values)
-  let _ = op.addInputList(shapes)
-  let _ = op.addInputList(denseInputs)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Adds up a SparseTensor and a dense Tensor, using these special rules:
-///
-/// (1) Broadcasts the dense side to have the same shape as the sparse side, if
-///     eligible;
-/// (2) Then, only the dense values pointed to by the indices of the SparseTensor
-///     participate in the cwise addition.
-///
-/// By these rules, the result is a logical SparseTensor with exactly the same
-/// indices and shape, but possibly with different non-zero values.  The output of
-/// this Op is the resultant non-zero values.
-///
-/// - Parameters:
-///   - sp_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
-///     SparseTensor, possibly not in canonical ordering.
-///   - sp_values: 1-D.  `N` non-empty values corresponding to `sp_indices`.
-///   - sp_shape: 1-D.  Shape of the input SparseTensor.
-///   - dense: `R`-D.  The dense Tensor operand.
-///
-/// - Output output: 1-D.  The `N` values that are operated on.
-@inlinable
-public static func sparseDenseCwiseAdd<T: Numeric & TensorFlowScalar>(
-  spIndices: Tensor<Int64>,
-  spValues: Tensor<T>,
-  spShape: Tensor<Int64>,
-  dense: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseDenseCwiseAdd")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(spIndices)
-  let _ = op.addInput(spValues)
-  let _ = op.addInput(spShape)
-  let _ = op.addInput(dense)
-  return op.execute(Int(1))
-}
-
-/// Component-wise divides a SparseTensor by a dense Tensor.
-///
-/// *Limitation*: this Op only broadcasts the dense side to the sparse side, but not
-/// the other direction.
-///
-/// - Parameters:
-///   - sp_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
-///     SparseTensor, possibly not in canonical ordering.
-///   - sp_values: 1-D.  `N` non-empty values corresponding to `sp_indices`.
-///   - sp_shape: 1-D.  Shape of the input SparseTensor.
-///   - dense: `R`-D.  The dense Tensor operand.
-///
-/// - Output output: 1-D.  The `N` values that are operated on.
-@inlinable
-public static func sparseDenseCwiseDiv<T: Numeric & TensorFlowScalar>(
-  spIndices: Tensor<Int64>,
-  spValues: Tensor<T>,
-  spShape: Tensor<Int64>,
-  dense: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseDenseCwiseDiv")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(spIndices)
-  let _ = op.addInput(spValues)
-  let _ = op.addInput(spShape)
-  let _ = op.addInput(dense)
-  return op.execute(Int(1))
-}
-
-/// Component-wise multiplies a SparseTensor by a dense Tensor.
-///
-/// The output locations corresponding to the implicitly zero elements in the sparse
-/// tensor will be zero (i.e., will not take up storage space), regardless of the
-/// contents of the dense tensor (even if it's +/-INF and that INF*0 == NaN).
-///
-/// *Limitation*: this Op only broadcasts the dense side to the sparse side, but not
-/// the other direction.
-///
-/// - Parameters:
-///   - sp_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
-///     SparseTensor, possibly not in canonical ordering.
-///   - sp_values: 1-D.  `N` non-empty values corresponding to `sp_indices`.
-///   - sp_shape: 1-D.  Shape of the input SparseTensor.
-///   - dense: `R`-D.  The dense Tensor operand.
-///
-/// - Output output: 1-D.  The `N` values that are operated on.
-@inlinable
-public static func sparseDenseCwiseMul<T: Numeric & TensorFlowScalar>(
-  spIndices: Tensor<Int64>,
-  spValues: Tensor<T>,
-  spShape: Tensor<Int64>,
-  dense: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseDenseCwiseMul")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(spIndices)
-  let _ = op.addInput(spValues)
-  let _ = op.addInput(spShape)
-  let _ = op.addInput(dense)
-  return op.execute(Int(1))
-}
-
-/// Fills empty rows in the input 2-D `SparseTensor` with a default value.
-///
-/// The input `SparseTensor` is represented via the tuple of inputs
-/// (`indices`, `values`, `dense_shape`).  The output `SparseTensor` has the
-/// same `dense_shape` but with indices `output_indices` and values
-/// `output_values`.
-///
-/// This op inserts a single entry for every row that doesn't have any values.
-/// The index is created as `[row, 0, ..., 0]` and the inserted value
-/// is `default_value`.
-///
-/// For example, suppose `sp_input` has shape `[5, 6]` and non-empty values:
-///
-///     [0, 1]: a
-///     [0, 3]: b
-///     [2, 0]: c
-///     [3, 1]: d
-///
-/// Rows 1 and 4 are empty, so the output will be of shape `[5, 6]` with values:
-///
-///     [0, 1]: a
-///     [0, 3]: b
-///     [1, 0]: default_value
-///     [2, 0]: c
-///     [3, 1]: d
-///     [4, 0]: default_value
-///
-/// The output `SparseTensor` will be in row-major order and will have the
-/// same shape as the input.
-///
-/// This op also returns an indicator vector shaped `[dense_shape[0]]` such that
-///
-///     empty_row_indicator[i] = True iff row i was an empty row.
-///
-/// And a reverse index map vector shaped `[indices.shape[0]]` that is used during
-/// backpropagation,
-///
-///     reverse_index_map[j] = out_j s.t. indices[j, :] == output_indices[out_j, :]
-///
-/// - Parameters:
-///   - indices: 2-D. the indices of the sparse tensor.
-///   - values: 1-D. the values of the sparse tensor.
-///   - dense_shape: 1-D. the shape of the sparse tensor.
-///   - default_value: 0-D. default value to insert into location `[row, 0, ..., 0]`
-///       for rows missing from the input sparse tensor.
-///     output indices: 2-D. the indices of the filled sparse tensor.
-///
-/// - Outputs:
-///   - output_values: 1-D. the values of the filled sparse tensor.
-///   - empty_row_indicator: 1-D. whether the dense row was missing in the
-///     input sparse tensor.
-///   - reverse_index_map: 1-D. a map from the input indices to the output indices.
-@inlinable
-public static func sparseFillEmptyRows<T: TensorFlowScalar>(
-  indices: Tensor<Int64>,
-  _ values: Tensor<T>,
-  denseShape: Tensor<Int64>,
-  defaultValue: Tensor<T>
-) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, emptyRowIndicator: Tensor<Bool>, reverseIndexMap: Tensor<Int64>) {
-  let op = TFE_Op("SparseFillEmptyRows")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(values)
-  let _ = op.addInput(denseShape)
-  let _ = op.addInput(defaultValue)
-  return op.execute(Int(1), Int(1), Int(1), Int(1))
-}
-
-/// The gradient of SparseFillEmptyRows.
-///
-/// Takes vectors reverse_index_map, shaped `[N]`, and grad_values,
-/// shaped `[N_full]`, where `N_full >= N` and copies data into either
-/// `d_values` or `d_default_value`.  Here `d_values` is shaped `[N]` and
-/// `d_default_value` is a scalar.
-///
-///   d_values[j] = grad_values[reverse_index_map[j]]
-///   d_default_value = sum_{k : 0 .. N_full - 1} (
-///      grad_values[k] * 1{k not in reverse_index_map})
-///
-/// - Parameters:
-///   - reverse_index_map: 1-D.  The reverse index map from SparseFillEmptyRows.
-///   - grad_values: 1-D.  The gradients from backprop.
-///
-/// - Outputs:
-///   - d_values: 1-D.  The backprop into values.
-///   - d_default_value: 0-D.  The backprop into default_value.
-@inlinable
-public static func sparseFillEmptyRowsGrad<T: TensorFlowScalar>(
-  reverseIndexMap: Tensor<Int64>,
-  gradValues: Tensor<T>
-) -> (dValues: Tensor<T>, dDefaultValue: Tensor<T>) {
-  let op = TFE_Op("SparseFillEmptyRowsGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(reverseIndexMap)
-  let _ = op.addInput(gradValues)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Multiply matrix "a" by matrix "b".
-///
-/// The inputs must be two-dimensional matrices and the inner dimension of "a" must
-/// match the outer dimension of "b". Both "a" and "b" must be `Tensor`s not
-/// `SparseTensor`s.  This op is optimized for the case where at least one of "a" or
-/// "b" is sparse, in the sense that they have a large proportion of zero values.
-/// The breakeven for using this versus a dense matrix multiply on one platform was
-/// 30% zero values in the sparse matrix.
-///
-/// The gradient computation of this operation will only take advantage of sparsity
-/// in the input gradient when that gradient comes from a Relu.
-@inlinable
-public static func sparseMatMul<
-    Ta: FloatingPoint & TensorFlowScalar,
-    Tb: FloatingPoint & TensorFlowScalar
->(
-  _ a: Tensor<Ta>,
-  _ b: Tensor<Tb>,
-  transposeA: Bool = false,
-  transposeB: Bool = false,
-  aIsSparse: Bool = false,
-  bIsSparse: Bool = false
-) -> Tensor<Float> {
-  let op = TFE_Op("SparseMatMul")
-  op.setAttr("transpose_a", transposeA)
-  op.setAttr("transpose_b", transposeB)
-  op.setAttr("a_is_sparse", aIsSparse)
-  op.setAttr("b_is_sparse", bIsSparse)
-  op.setAttr("Ta", Ta.tensorFlowDataType)
-  op.setAttr("Tb", Tb.tensorFlowDataType)
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  return op.execute(Int(1))
-}
-
-/// Computes the max of elements across dimensions of a SparseTensor.
-///
-/// This Op takes a SparseTensor and is the sparse counterpart to
-/// `tf.reduce_max()`.  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
-/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-/// `reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
-/// with length 1.
-///
-/// If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
-/// with a single element is returned.  Additionally, the axes can be negative,
-/// which are interpreted according to the indexing rules in Python.
-///
-/// - Parameters:
-///   - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
-///     SparseTensor, possibly not in canonical ordering.
-///   - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
-///   - input_shape: 1-D.  Shape of the input SparseTensor.
-///   - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
-///
-/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-///
-/// - Output output: `R-K`-D.  The reduced Tensor.
-@inlinable
-public static func sparseReduceMax<T: Numeric & TensorFlowScalar>(
-  inputIndices: Tensor<Int64>,
-  inputValues: Tensor<T>,
-  inputShape: Tensor<Int64>,
-  reductionAxes: Tensor<Int32>,
-  keepDims: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("SparseReduceMax")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(inputIndices)
-  let _ = op.addInput(inputValues)
-  let _ = op.addInput(inputShape)
-  let _ = op.addInput(reductionAxes)
-  return op.execute(Int(1))
-}
-
-/// Computes the max of elements across dimensions of a SparseTensor.
-///
-/// This Op takes a SparseTensor and is the sparse counterpart to
-/// `tf.reduce_max()`.  In contrast to SparseReduceMax, this Op returns a
-/// SparseTensor.
-///
-/// Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
-/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-/// `reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
-/// with length 1.
-///
-/// If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
-/// with a single element is returned.  Additionally, the axes can be negative,
-/// which are interpreted according to the indexing rules in Python.
-///
-/// - Parameters:
-///   - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
-///     SparseTensor, possibly not in canonical ordering.
-///   - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
-///   - input_shape: 1-D.  Shape of the input SparseTensor.
-///   - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
-///
-/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-@inlinable
-public static func sparseReduceMaxSparse<T: Numeric & TensorFlowScalar>(
-  inputIndices: Tensor<Int64>,
-  inputValues: Tensor<T>,
-  inputShape: Tensor<Int64>,
-  reductionAxes: Tensor<Int32>,
-  keepDims: Bool = false
-) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, outputShape: Tensor<Int64>) {
-  let op = TFE_Op("SparseReduceMaxSparse")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(inputIndices)
-  let _ = op.addInput(inputValues)
-  let _ = op.addInput(inputShape)
-  let _ = op.addInput(reductionAxes)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Computes the sum of elements across dimensions of a SparseTensor.
-///
-/// 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
-/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-/// `reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
-/// with length 1.
-///
-/// If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
-/// with a single element is returned.  Additionally, the axes can be negative,
-/// which are interpreted according to the indexing rules in Python.
-///
-/// - Parameters:
-///   - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
-///     SparseTensor, possibly not in canonical ordering.
-///   - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
-///   - input_shape: 1-D.  Shape of the input SparseTensor.
-///   - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
-///
-/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-///
-/// - Output output: `R-K`-D.  The reduced Tensor.
-@inlinable
-public static func sparseReduceSum<T: Numeric & TensorFlowScalar>(
-  inputIndices: Tensor<Int64>,
-  inputValues: Tensor<T>,
-  inputShape: Tensor<Int64>,
-  reductionAxes: Tensor<Int32>,
-  keepDims: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("SparseReduceSum")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(inputIndices)
-  let _ = op.addInput(inputValues)
-  let _ = op.addInput(inputShape)
-  let _ = op.addInput(reductionAxes)
-  return op.execute(Int(1))
-}
-
-/// Computes the sum of elements across dimensions of a SparseTensor.
-///
-/// This Op takes a SparseTensor and is the sparse counterpart to
-/// `tf.reduce_sum()`.  In contrast to SparseReduceSum, this Op returns a
-/// SparseTensor.
-///
-/// Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
-/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-/// `reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
-/// with length 1.
-///
-/// If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
-/// with a single element is returned.  Additionally, the axes can be negative,
-/// which are interpreted according to the indexing rules in Python.
-///
-/// - Parameters:
-///   - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
-///     SparseTensor, possibly not in canonical ordering.
-///   - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
-///   - input_shape: 1-D.  Shape of the input SparseTensor.
-///   - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
-///
-/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-@inlinable
-public static func sparseReduceSumSparse<T: Numeric & TensorFlowScalar>(
-  inputIndices: Tensor<Int64>,
-  inputValues: Tensor<T>,
-  inputShape: Tensor<Int64>,
-  reductionAxes: Tensor<Int32>,
-  keepDims: Bool = false
-) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, outputShape: Tensor<Int64>) {
-  let op = TFE_Op("SparseReduceSumSparse")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(inputIndices)
-  let _ = op.addInput(inputValues)
-  let _ = op.addInput(inputShape)
-  let _ = op.addInput(reductionAxes)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Reorders a SparseTensor into the canonical, row-major ordering.
-///
-/// Note that by convention, all sparse ops preserve the canonical ordering along
-/// increasing dimension number. The only time ordering can be violated is during
-/// manual manipulation of the indices and values vectors to add entries.
-///
-/// Reordering does not affect the shape of the SparseTensor.
-///
-/// If the tensor has rank `R` and `N` non-empty values, `input_indices` has
-/// shape `[N, R]`, input_values has length `N`, and input_shape has length `R`.
-///
-/// - Parameters:
-///   - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
-///     SparseTensor, possibly not in canonical ordering.
-///   - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
-///   - input_shape: 1-D.  Shape of the input SparseTensor.
-///
-/// - Outputs:
-///   - output_indices: 2-D.  `N x R` matrix with the same indices as input_indices, but
-///     in canonical row-major ordering.
-///   - output_values: 1-D.  `N` non-empty values corresponding to `output_indices`.
-@inlinable
-public static func sparseReorder<T: TensorFlowScalar>(
-  inputIndices: Tensor<Int64>,
-  inputValues: Tensor<T>,
-  inputShape: Tensor<Int64>
-) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>) {
-  let op = TFE_Op("SparseReorder")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(inputIndices)
-  let _ = op.addInput(inputValues)
-  let _ = op.addInput(inputShape)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Reshapes a SparseTensor to represent values in a new dense shape.
-///
-/// This operation has the same semantics as reshape on the represented dense
-/// tensor.  The `input_indices` are recomputed based on the requested `new_shape`.
-///
-/// If one component of `new_shape` is the special value -1, the size of that
-/// dimension is computed so that the total dense size remains constant.  At
-/// most one component of `new_shape` can be -1.  The number of dense elements
-/// implied by `new_shape` must be the same as the number of dense elements
-/// originally implied by `input_shape`.
-///
-/// Reshaping does not affect the order of values in the SparseTensor.
-///
-/// If the input tensor has rank `R_in` and `N` non-empty values, and `new_shape`
-/// has length `R_out`, then `input_indices` has shape `[N, R_in]`,
-/// `input_shape` has length `R_in`, `output_indices` has shape `[N, R_out]`, and
-/// `output_shape` has length `R_out`.
-///
-/// - Parameters:
-///   - input_indices: 2-D.  `N x R_in` matrix with the indices of non-empty values in a
-///     SparseTensor.
-///   - input_shape: 1-D.  `R_in` vector with the input SparseTensor's dense shape.
-///   - new_shape: 1-D.  `R_out` vector with the requested new dense shape.
-///
-/// - Outputs:
-///   - output_indices: 2-D.  `N x R_out` matrix with the updated indices of non-empty
-///     values in the output SparseTensor.
-///   - output_shape: 1-D.  `R_out` vector with the full dense shape of the output
-///     SparseTensor.  This is the same as `new_shape` but with any -1 dimensions
-///     filled in.
-@inlinable
-public static func sparseReshape(
-  inputIndices: Tensor<Int64>,
-  inputShape: Tensor<Int64>,
-  newShape: Tensor<Int64>
-) -> (outputIndices: Tensor<Int64>, outputShape: Tensor<Int64>) {
-  let op = TFE_Op("SparseReshape")
-  let _ = op.addInput(inputIndices)
-  let _ = op.addInput(inputShape)
-  let _ = op.addInput(newShape)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Computes the mean along sparse segments of a tensor.
-///
-/// See `tf.sparse.segment_sum` for usage examples.
-///
-/// Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first
-/// dimension, selecting a subset of dimension 0, specified by `indices`.
-///
-/// - Parameters:
-///   - indices: A 1-D tensor. Has same rank as `segment_ids`.
-///   - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
-///
-/// - Output output: Has same shape as data, except for dimension 0 which
-///   has size `k`, the number of segments.
-@inlinable
-public static func sparseSegmentMean<
-    T: FloatingPoint & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  indices: Tensor<Tidx>,
-  segmentIds: Tensor<Int32>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseSegmentMean")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(segmentIds)
-  return op.execute(Int(1))
-}
-
-/// Computes gradients for SparseSegmentMean.
-///
-/// Returns tensor "output" with same shape as grad, except for dimension 0 whose
-/// value is output_dim0.
-///
-/// - Parameters:
-///   - grad: gradient propagated to the SparseSegmentMean op.
-///   - indices: indices passed to the corresponding SparseSegmentMean op.
-///   - segment_ids: segment_ids passed to the corresponding SparseSegmentMean op.
-///   - output_dim0: dimension 0 of "data" passed to SparseSegmentMean op.
-@inlinable
-public static func sparseSegmentMeanGrad<
-    T: FloatingPoint & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  grad: Tensor<T>,
-  indices: Tensor<Tidx>,
-  segmentIds: Tensor<Int32>,
-  outputDim0: Tensor<Int32>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseSegmentMeanGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(segmentIds)
-  let _ = op.addInput(outputDim0)
-  return op.execute(Int(1))
-}
-
-/// Computes the mean along sparse segments of a tensor.
-///
-/// Like `SparseSegmentMean`, but allows missing ids in `segment_ids`. If an id is
-/// misisng, the `output` tensor at that position will be zeroed.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
-/// for an explanation of segments.
-///
-/// - Parameters:
-///   - indices: A 1-D tensor. Has same rank as `segment_ids`.
-///   - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
-///   - num_segments: Should equal the number of distinct segment IDs.
-///
-/// - Output output: Has same shape as data, except for dimension 0 which has size
-///   `num_segments`.
-@inlinable
-public static func sparseSegmentMeanWithNumSegments<
-    T: FloatingPoint & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar,
-    Tnumsegments: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  indices: Tensor<Tidx>,
-  segmentIds: Tensor<Int32>,
-  numSegments: Tensor<Tnumsegments>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseSegmentMeanWithNumSegments")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(segmentIds)
-  let _ = op.addInput(numSegments)
-  return op.execute(Int(1))
-}
-
-/// Computes the sum along sparse segments of a tensor divided by the sqrt of N.
-///
-/// N is the size of the segment being reduced.
-///
-/// See `tf.sparse.segment_sum` for usage examples.
-///
-///
-/// - Parameters:
-///   - indices: A 1-D tensor. Has same rank as `segment_ids`.
-///   - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
-///
-/// - Output output: Has same shape as data, except for dimension 0 which
-///   has size `k`, the number of segments.
-@inlinable
-public static func sparseSegmentSqrtN<
-    T: FloatingPoint & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  indices: Tensor<Tidx>,
-  segmentIds: Tensor<Int32>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseSegmentSqrtN")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(segmentIds)
-  return op.execute(Int(1))
-}
-
-/// Computes gradients for SparseSegmentSqrtN.
-///
-/// Returns tensor "output" with same shape as grad, except for dimension 0 whose
-/// value is output_dim0.
-///
-/// - Parameters:
-///   - grad: gradient propagated to the SparseSegmentSqrtN op.
-///   - indices: indices passed to the corresponding SparseSegmentSqrtN op.
-///   - segment_ids: segment_ids passed to the corresponding SparseSegmentSqrtN op.
-///   - output_dim0: dimension 0 of "data" passed to SparseSegmentSqrtN op.
-@inlinable
-public static func sparseSegmentSqrtNGrad<
-    T: FloatingPoint & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  grad: Tensor<T>,
-  indices: Tensor<Tidx>,
-  segmentIds: Tensor<Int32>,
-  outputDim0: Tensor<Int32>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseSegmentSqrtNGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(segmentIds)
-  let _ = op.addInput(outputDim0)
-  return op.execute(Int(1))
-}
-
-/// Computes the sum along sparse segments of a tensor divided by the sqrt of N.
-///
-/// N is the size of the segment being reduced.
-///
-/// Like `SparseSegmentSqrtN`, but allows missing ids in `segment_ids`. If an id is
-/// misisng, the `output` tensor at that position will be zeroed.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
-/// for an explanation of segments.
-///
-/// - Parameters:
-///   - indices: A 1-D tensor. Has same rank as `segment_ids`.
-///   - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
-///   - num_segments: Should equal the number of distinct segment IDs.
-///
-/// - Output output: Has same shape as data, except for dimension 0 which
-///   has size `k`, the number of segments.
-@inlinable
-public static func sparseSegmentSqrtNWithNumSegments<
-    T: FloatingPoint & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar,
-    Tnumsegments: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  indices: Tensor<Tidx>,
-  segmentIds: Tensor<Int32>,
-  numSegments: Tensor<Tnumsegments>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseSegmentSqrtNWithNumSegments")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(segmentIds)
-  let _ = op.addInput(numSegments)
-  return op.execute(Int(1))
-}
-
-/// Computes the sum along sparse segments of a tensor.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
-/// for an explanation of segments.
-///
-/// Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first
-/// dimension, selecting a subset of dimension 0, specified by `indices`.
-///
-/// For example:
-///
-/// ```python
-/// c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
-///
-/// # Select two rows, one segment.
-/// tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))
-/// # => [[0 0 0 0]]
-///
-/// # Select two rows, two segment.
-/// tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))
-/// # => [[ 1  2  3  4]
-/// #     [-1 -2 -3 -4]]
-///
-/// # Select all rows, two segments.
-/// tf.sparse_segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))
-/// # => [[0 0 0 0]
-/// #     [5 6 7 8]]
-///
-/// # Which is equivalent to:
-/// tf.segment_sum(c, tf.constant([0, 0, 1]))
-/// ```
-///
-/// - Parameters:
-///   - indices: A 1-D tensor. Has same rank as `segment_ids`.
-///   - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
-///
-/// - Output output: Has same shape as data, except for dimension 0 which
-///   has size `k`, the number of segments.
-@inlinable
-public static func sparseSegmentSum<
-    T: Numeric & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  indices: Tensor<Tidx>,
-  segmentIds: Tensor<Int32>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseSegmentSum")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(segmentIds)
-  return op.execute(Int(1))
-}
-
-/// Computes the sum along sparse segments of a tensor.
-///
-/// Like `SparseSegmentSum`, but allows missing ids in `segment_ids`. If an id is
-/// misisng, the `output` tensor at that position will be zeroed.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/sparse#Segmentation)
-/// for an explanation of segments.
-///
-/// For example:
-///
-/// ```python
-/// c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
-///
-/// tf.sparse_segment_sum_with_num_segments(
-///     c, tf.constant([0, 1]), tf.constant([0, 0]), num_segments=3)
-/// # => [[0 0 0 0]
-/// #     [0 0 0 0]
-/// #     [0 0 0 0]]
-///
-/// tf.sparse_segment_sum_with_num_segments(c,
-///                                         tf.constant([0, 1]),
-///                                         tf.constant([0, 2],
-///                                         num_segments=4))
-/// # => [[ 1  2  3  4]
-/// #     [ 0  0  0  0]
-/// #     [-1 -2 -3 -4]
-/// #     [ 0  0  0  0]]
-/// ```
-///
-/// - Parameters:
-///   - indices: A 1-D tensor. Has same rank as `segment_ids`.
-///   - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
-///   - num_segments: Should equal the number of distinct segment IDs.
-///
-/// - Output output: Has same shape as data, except for dimension 0 which
-///   has size `num_segments`.
-@inlinable
-public static func sparseSegmentSumWithNumSegments<
-    T: Numeric & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar,
-    Tnumsegments: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  indices: Tensor<Tidx>,
-  segmentIds: Tensor<Int32>,
-  numSegments: Tensor<Tnumsegments>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseSegmentSumWithNumSegments")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(segmentIds)
-  let _ = op.addInput(numSegments)
-  return op.execute(Int(1))
-}
-
-/// Slice a `SparseTensor` based on the `start` and `size`.
-///
-/// For example, if the input is
-///
-///     input_tensor = shape = [2, 7]
-///     [    a   d e  ]
-///     [b c          ]
-///
-/// Graphically the output tensors are:
-///
-///     sparse_slice([0, 0], [2, 4]) = shape = [2, 4]
-///     [    a  ]
-///     [b c    ]
-///
-///     sparse_slice([0, 4], [2, 3]) = shape = [2, 3]
-///     [ d e  ]
-///     [      ]
-///
-/// - Parameters:
-///   - indices: 2-D tensor represents the indices of the sparse tensor.
-///   - values: 1-D tensor represents the values of the sparse tensor.
-///   - shape: 1-D. tensor represents the shape of the sparse tensor.
-///   - start: 1-D. tensor represents the start of the slice.
-///   - size: 1-D. tensor represents the size of the slice.
-///     output indices: A list of 1-D tensors represents the indices of the output
-///     sparse tensors.
-///
-/// - Outputs:
-///   - output_values: A list of 1-D tensors represents the values of the output sparse
-///     tensors.
-///   - output_shape: A list of 1-D tensors represents the shape of the output sparse
-///     tensors.
-@inlinable
-public static func sparseSlice<T: TensorFlowScalar>(
-  indices: Tensor<Int64>,
-  _ values: Tensor<T>,
-  shape: Tensor<Int64>,
-  start: Tensor<Int64>,
-  size: Tensor<Int64>
-) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, outputShape: Tensor<Int64>) {
-  let op = TFE_Op("SparseSlice")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(values)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(start)
-  let _ = op.addInput(size)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// The gradient operator for the SparseSlice op.
-///
-/// This op takes in the upstream gradient w.r.t. non-empty values of
-/// the sliced `SparseTensor`, and outputs the gradients w.r.t.
-/// the non-empty values of input `SparseTensor`.
-///
-/// - Parameters:
-///   - backprop_val_grad: 1-D. The gradient with respect to
-///     the non-empty values of the sliced `SparseTensor`.
-///   - input_indices: 2-D.  The `indices` of the input `SparseTensor`.
-///   - input_start: 1-D. tensor represents the start of the slice.
-///   - output_indices: 2-D.  The `indices` of the sliced `SparseTensor`.
-///
-/// - Output val_grad: 1-D. The gradient with respect to the non-empty values of input `SparseTensor`.
-@inlinable
-public static func sparseSliceGrad<T: Numeric & TensorFlowScalar>(
-  backpropValGrad: Tensor<T>,
-  inputIndices: Tensor<Int64>,
-  inputStart: Tensor<Int64>,
-  outputIndices: Tensor<Int64>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseSliceGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(backpropValGrad)
-  let _ = op.addInput(inputIndices)
-  let _ = op.addInput(inputStart)
-  let _ = op.addInput(outputIndices)
-  return op.execute(Int(1))
-}
-
-/// Applies softmax to a batched N-D `SparseTensor`.
-///
-/// The inputs represent an N-D SparseTensor  with logical shape `[..., B, C]`
-/// (where `N >= 2`), and with indices sorted in the canonical lexicographic order.
-///
-/// This op is equivalent to applying the normal `tf.nn.softmax()` to each innermost
-/// logical submatrix with shape `[B, C]`, but with the catch that *the implicitly
-/// zero elements do not participate*.  Specifically, the algorithm is equivalent
-/// to the following:
-///
-///   (1) Applies `tf.nn.softmax()` to a densified view of each innermost submatrix
-///       with shape `[B, C]`, along the size-C dimension;
-///   (2) Masks out the original implicitly-zero locations;
-///   (3) Renormalizes the remaining elements.
-///
-/// Hence, the `SparseTensor` result has exactly the same non-zero indices and
-/// shape.
-///
-/// - Parameters:
-///   - sp_indices: 2-D.  `NNZ x R` matrix with the indices of non-empty values in a
-///     SparseTensor, in canonical ordering.
-///   - sp_values: 1-D.  `NNZ` non-empty values corresponding to `sp_indices`.
-///   - sp_shape: 1-D.  Shape of the input SparseTensor.
-///
-/// - Output output: 1-D.  The `NNZ` values for the result `SparseTensor`.
-@inlinable
-public static func sparseSoftmax<T: FloatingPoint & TensorFlowScalar>(
-  spIndices: Tensor<Int64>,
-  spValues: Tensor<T>,
-  spShape: Tensor<Int64>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseSoftmax")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(spIndices)
-  let _ = op.addInput(spValues)
-  let _ = op.addInput(spShape)
-  return op.execute(Int(1))
-}
-
-/// Computes softmax cross entropy cost and gradients to backpropagate.
-///
-/// Unlike `SoftmaxCrossEntropyWithLogits`, this operation does not accept
-/// a matrix of label probabilities, but rather a single label per row
-/// of features.  This label is considered to have probability 1.0 for the
-/// given row.
-///
-/// Inputs are the logits, not probabilities.
-///
-/// - Parameters:
-///   - features: batch_size x num_classes matrix
-///   - labels: batch_size vector with values in [0, num_classes).
-///     This is the label for the given minibatch entry.
-///
-/// - Outputs:
-///   - loss: Per example loss (batch_size vector).
-///   - backprop: backpropagated gradients (batch_size x num_classes matrix).
-@inlinable
-public static func sparseSoftmaxCrossEntropyWithLogits<
-    T: FloatingPoint & TensorFlowScalar,
-    Tlabels: BinaryInteger & TensorFlowScalar
->(
-  features: Tensor<T>,
-  labels: Tensor<Tlabels>
-) -> (loss: Tensor<T>, backprop: Tensor<T>) {
-  let op = TFE_Op("SparseSoftmaxCrossEntropyWithLogits")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tlabels", Tlabels.tensorFlowDataType)
-  let _ = op.addInput(features)
-  let _ = op.addInput(labels)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Returns the element-wise max of two SparseTensors.
-///
-/// Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
-///
-/// - Parameters:
-///   - 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.
-///
-/// - Outputs:
-///   - output_indices: 2-D.  The indices of the output SparseTensor.
-///   - output_values: 1-D.  The values of the output SparseTensor.
-@inlinable
-public static func sparseSparseMaximum<T: Numeric & TensorFlowScalar>(
-  aIndices: Tensor<Int64>,
-  aValues: Tensor<T>,
-  aShape: Tensor<Int64>,
-  bIndices: Tensor<Int64>,
-  bValues: Tensor<T>,
-  bShape: Tensor<Int64>
-) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>) {
-  let op = TFE_Op("SparseSparseMaximum")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(aIndices)
-  let _ = op.addInput(aValues)
-  let _ = op.addInput(aShape)
-  let _ = op.addInput(bIndices)
-  let _ = op.addInput(bValues)
-  let _ = op.addInput(bShape)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Returns the element-wise min of two SparseTensors.
-///
-/// Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
-///
-/// - Parameters:
-///   - 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.
-///
-/// - Outputs:
-///   - output_indices: 2-D.  The indices of the output SparseTensor.
-///   - output_values: 1-D.  The values of the output SparseTensor.
-@inlinable
-public static func sparseSparseMinimum<T: Numeric & TensorFlowScalar>(
-  aIndices: Tensor<Int64>,
-  aValues: Tensor<T>,
-  aShape: Tensor<Int64>,
-  bIndices: Tensor<Int64>,
-  bValues: Tensor<T>,
-  bShape: Tensor<Int64>
-) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>) {
-  let op = TFE_Op("SparseSparseMinimum")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(aIndices)
-  let _ = op.addInput(aValues)
-  let _ = op.addInput(aShape)
-  let _ = op.addInput(bIndices)
-  let _ = op.addInput(bValues)
-  let _ = op.addInput(bShape)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Split a `SparseTensor` into `num_split` tensors along one dimension.
-///
-/// If the `shape[split_dim]` is not an integer multiple of `num_split`. Slices
-/// `[0 : shape[split_dim] % num_split]` gets one extra dimension.
-/// For example, if `split_dim = 1` and `num_split = 2` and the input is
-///
-///     input_tensor = shape = [2, 7]
-///     [    a   d e  ]
-///     [b c          ]
-///
-/// Graphically the output tensors are:
-///
-///     output_tensor[0] = shape = [2, 4]
-///     [    a  ]
-///     [b c    ]
-///
-///     output_tensor[1] = shape = [2, 3]
-///     [ d e  ]
-///     [      ]
-///
-/// - Parameters:
-///   - split_dim: 0-D.  The dimension along which to split.  Must be in the range
-///     `[0, rank(shape))`.
-///   - indices: 2-D tensor represents the indices of the sparse tensor.
-///   - values: 1-D tensor represents the values of the sparse tensor.
-///   - shape: 1-D. tensor represents the shape of the sparse tensor.
-///     output indices: A list of 1-D tensors represents the indices of the output
-///     sparse tensors.
-///
-/// - Attr num_split: The number of ways to split.
-///
-/// - Outputs:
-///   - output_values: A list of 1-D tensors represents the values of the output sparse
-///     tensors.
-///   - output_shape: A list of 1-D tensors represents the shape of the output sparse
-///     tensors.
-@inlinable
-public static func sparseSplit<T: TensorFlowScalar>(
-  splitDim: Tensor<Int64>,
-  indices: Tensor<Int64>,
-  _ values: Tensor<T>,
-  shape: Tensor<Int64>,
-  numSplit: Int64
-) -> (outputIndices: [Tensor<Int64>], outputValues: [Tensor<T>], outputShape: [Tensor<Int64>]) {
-  let op = TFE_Op("SparseSplit")
-  op.setAttr("num_split", numSplit)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(splitDim)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(values)
-  let _ = op.addInput(shape)
-  return op.execute(Int(numSplit), Int(numSplit), Int(numSplit))
-}
-
-/// Adds up a `SparseTensor` and a dense `Tensor`, producing a dense `Tensor`.
-///
-/// This Op does not require `a_indices` be sorted in standard lexicographic order.
-///
-/// - Parameters:
-///   - a_indices: 2-D.  The `indices` of the `SparseTensor`, with shape `[nnz, ndims]`.
-///   - a_values: 1-D.  The `values` of the `SparseTensor`, with shape `[nnz]`.
-///   - a_shape: 1-D.  The `shape` of the `SparseTensor`, with shape `[ndims]`.
-///   - b: `ndims`-D Tensor.  With shape `a_shape`.
-@inlinable
-public static func sparseTensorDenseAdd<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  aIndices: Tensor<Tindices>,
-  aValues: Tensor<T>,
-  aShape: Tensor<Tindices>,
-  _ b: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("SparseTensorDenseAdd")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(aIndices)
-  let _ = op.addInput(aValues)
-  let _ = op.addInput(aShape)
-  let _ = op.addInput(b)
-  return op.execute(Int(1))
-}
-
-/// Multiply SparseTensor (of rank 2) "A" by dense matrix "B".
-///
-/// No validity checking is performed on the indices of A.  However, the following
-/// input format is recommended for optimal behavior:
-///
-/// if adjoint_a == false:
-///   A should be sorted in lexicographically increasing order.  Use SparseReorder
-///   if you're not sure.
-/// if adjoint_a == true:
-///   A should be sorted in order of increasing dimension 1 (i.e., "column major"
-///   order instead of "row major" order).
-///
-/// - Parameters:
-///   - a_indices: 2-D.  The `indices` of the `SparseTensor`, size `[nnz, 2]` Matrix.
-///   - a_values: 1-D.  The `values` of the `SparseTensor`, size `[nnz]` Vector.
-///   - a_shape: 1-D.  The `shape` of the `SparseTensor`, size `[2]` Vector.
-///   - b: 2-D.  A dense Matrix.
-///
-/// - Attrs:
-///   - adjoint_a: Use the adjoint of A in the matrix multiply.  If A is complex, this
-///     is transpose(conj(A)).  Otherwise it's transpose(A).
-///   - adjoint_b: Use the adjoint of B in the matrix multiply.  If B is complex, this
-///     is transpose(conj(B)).  Otherwise it's transpose(B).
-@inlinable
-public static func sparseTensorDenseMatMul<
-    T: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  aIndices: Tensor<Tindices>,
-  aValues: Tensor<T>,
-  aShape: Tensor<Int64>,
-  _ b: Tensor<T>,
-  adjointA: Bool = false,
-  adjointB: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("SparseTensorDenseMatMul")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("adjoint_a", adjointA)
-  op.setAttr("adjoint_b", adjointB)
-  let _ = op.addInput(aIndices)
-  let _ = op.addInput(aValues)
-  let _ = op.addInput(aShape)
-  let _ = op.addInput(b)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that splits a SparseTensor into elements row-wise.
-@inlinable
-public static func sparseTensorSliceDataset<Tvalues: TensorFlowScalar>(
-  indices: Tensor<Int64>,
-  _ values: Tensor<Tvalues>,
-  denseShape: Tensor<Int64>
-) -> VariantHandle {
-  let op = TFE_Op("SparseTensorSliceDataset")
-  op.setAttr("Tvalues", Tvalues.tensorFlowDataType)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(values)
-  let _ = op.addInput(denseShape)
-  return op.execute(Int(1))
-}
-
-/// Converts a sparse representation into a dense tensor.
-///
-/// Builds an array `dense` with shape `output_shape` such that
-///
-/// ```
-/// # If sparse_indices is scalar
-/// dense[i] = (i == sparse_indices ? sparse_values : default_value)
-///
-/// # If sparse_indices is a vector, then for each i
-/// dense[sparse_indices[i]] = sparse_values[i]
-///
-/// # If sparse_indices is an n by d matrix, then for each i in [0, n)
-/// dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i]
-/// ```
-///
-/// All other values in `dense` are set to `default_value`.  If `sparse_values` is a
-/// scalar, all sparse indices are set to this single value.
-///
-/// Indices should be sorted in lexicographic order, and indices must not
-/// contain any repeats. If `validate_indices` is true, these properties
-/// are checked during execution.
-///
-/// - Parameters:
-///   - sparse_indices: 0-D, 1-D, or 2-D.  `sparse_indices[i]` contains the complete
-///     index where `sparse_values[i]` will be placed.
-///   - output_shape: 1-D.  Shape of the dense output tensor.
-///   - sparse_values: 1-D.  Values corresponding to each row of `sparse_indices`,
-///     or a scalar value to be used for all sparse indices.
-///   - default_value: Scalar value to set for indices not specified in
-///     `sparse_indices`.
-///
-/// - Attr validate_indices: If true, indices are checked to make sure they are sorted in
-///   lexicographic order and that there are no repeats.
-///
-/// - Output dense: Dense output tensor of shape `output_shape`.
-@inlinable
-public static func sparseToDense<
-    T: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  sparseIndices: Tensor<Tindices>,
-  outputShape: Tensor<Tindices>,
-  sparseValues: Tensor<T>,
-  defaultValue: Tensor<T>,
-  validateIndices: Bool = true
-) -> Tensor<T> {
-  let op = TFE_Op("SparseToDense")
-  op.setAttr("validate_indices", validateIndices)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(sparseIndices)
-  let _ = op.addInput(outputShape)
-  let _ = op.addInput(sparseValues)
-  let _ = op.addInput(defaultValue)
-  return op.execute(Int(1))
-}
-
-/// Applies set operation along last dimension of 2 `SparseTensor` inputs.
-///
-/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
-///
-/// If `validate_indices` is `True`, `SparseToSparseSetOperation` validates the
-/// order and range of `set1` and `set2` indices.
-///
-/// Input `set1` is a `SparseTensor` represented by `set1_indices`, `set1_values`,
-/// and `set1_shape`. For `set1` ranked `n`, 1st `n-1` dimensions must be the same
-/// as `set2`. Dimension `n` contains values in a set, duplicates are allowed but
-/// ignored.
-///
-/// Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
-/// and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
-/// as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
-/// ignored.
-///
-/// If `validate_indices` is `True`, this op validates the order and range of `set1`
-/// and `set2` indices.
-///
-/// Output `result` is a `SparseTensor` represented by `result_indices`,
-/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
-/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
-/// dimension contains the result of `set_operation` applied to the corresponding
-/// `[0...n-1]` dimension of `set`.
-///
-/// - Parameters:
-///   - set1_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
-///     order.
-///   - set1_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
-///     order.
-///   - set1_shape: 1D `Tensor`, shape of a `SparseTensor`. `set1_shape[0...n-1]` must
-///     be the same as `set2_shape[0...n-1]`, `set1_shape[n]` is the
-///     max set size across `0...n-1` dimensions.
-///   - set2_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
-///     order.
-///   - set2_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
-///     order.
-///   - set2_shape: 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
-///     be the same as `set1_shape[0...n-1]`, `set2_shape[n]` is the
-///     max set size across `0...n-1` dimensions.
-///
-/// - Outputs:
-///   - result_indices: 2D indices of a `SparseTensor`.
-///   - result_values: 1D values of a `SparseTensor`.
-///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
-///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
-///     is the max result set size across all `0...n-1` dimensions.
-@inlinable
-public static func sparseToSparseSetOperation<T: BinaryInteger & TensorFlowScalar>(
-  set1Indices: Tensor<Int64>,
-  set1Values: Tensor<T>,
-  set1Shape: Tensor<Int64>,
-  set2Indices: Tensor<Int64>,
-  set2Values: Tensor<T>,
-  set2Shape: Tensor<Int64>,
-  setOperation: String,
-  validateIndices: Bool = true
-) -> (resultIndices: Tensor<Int64>, resultValues: Tensor<T>, resultShape: Tensor<Int64>) {
-  let op = TFE_Op("SparseToSparseSetOperation")
-  op.setAttr("set_operation", setOperation)
-  op.setAttr("validate_indices", validateIndices)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(set1Indices)
-  let _ = op.addInput(set1Values)
-  let _ = op.addInput(set1Shape)
-  let _ = op.addInput(set2Indices)
-  let _ = op.addInput(set2Values)
-  let _ = op.addInput(set2Shape)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Applies set operation along last dimension of 2 `SparseTensor` inputs.
-///
-/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
-///
-/// If `validate_indices` is `True`, `SparseToSparseSetOperation` validates the
-/// order and range of `set1` and `set2` indices.
-///
-/// Input `set1` is a `SparseTensor` represented by `set1_indices`, `set1_values`,
-/// and `set1_shape`. For `set1` ranked `n`, 1st `n-1` dimensions must be the same
-/// as `set2`. Dimension `n` contains values in a set, duplicates are allowed but
-/// ignored.
-///
-/// Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
-/// and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
-/// as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
-/// ignored.
-///
-/// If `validate_indices` is `True`, this op validates the order and range of `set1`
-/// and `set2` indices.
-///
-/// Output `result` is a `SparseTensor` represented by `result_indices`,
-/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
-/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
-/// dimension contains the result of `set_operation` applied to the corresponding
-/// `[0...n-1]` dimension of `set`.
-///
-/// - Parameters:
-///   - set1_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
-///     order.
-///   - set1_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
-///     order.
-///   - set1_shape: 1D `Tensor`, shape of a `SparseTensor`. `set1_shape[0...n-1]` must
-///     be the same as `set2_shape[0...n-1]`, `set1_shape[n]` is the
-///     max set size across `0...n-1` dimensions.
-///   - set2_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
-///     order.
-///   - set2_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
-///     order.
-///   - set2_shape: 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
-///     be the same as `set1_shape[0...n-1]`, `set2_shape[n]` is the
-///     max set size across `0...n-1` dimensions.
-///
-/// - Outputs:
-///   - result_indices: 2D indices of a `SparseTensor`.
-///   - result_values: 1D values of a `SparseTensor`.
-///   - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
-///     the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
-///     is the max result set size across all `0...n-1` dimensions.
-@inlinable
-public static func sparseToSparseSetOperation(
-  set1Indices: Tensor<Int64>,
-  set1Values: StringTensor,
-  set1Shape: Tensor<Int64>,
-  set2Indices: Tensor<Int64>,
-  set2Values: StringTensor,
-  set2Shape: Tensor<Int64>,
-  setOperation: String,
-  validateIndices: Bool = true
-) -> (resultIndices: Tensor<Int64>, resultValues: StringTensor, resultShape: Tensor<Int64>) {
-  let op = TFE_Op("SparseToSparseSetOperation")
-  op.setAttr("set_operation", setOperation)
-  op.setAttr("validate_indices", validateIndices)
-  op.setAttr("T", TensorDataType(TF_STRING))
-  let _ = op.addInput(set1Indices)
-  let _ = op.addInput(set1Values)
-  let _ = op.addInput(set1Shape)
-  let _ = op.addInput(set2Indices)
-  let _ = op.addInput(set2Values)
-  let _ = op.addInput(set2Shape)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Splits a tensor into `num_split` tensors along one dimension.
-///
-/// - Parameters:
-///   - split_dim: 0-D.  The dimension along which to split.  Must be in the range
-///     `[-rank(value), rank(value))`.
-///   - value: The tensor to split.
-///
-/// - Attr num_split: The number of ways to split.  Must evenly divide
-///   `value.shape[split_dim]`.
-///
-/// - Output output: They are identically shaped tensors, whose shape matches that of `value`
-///   except along `axis`, where their sizes are
-///   `values.shape[split_dim] / num_split`.
-@inlinable
-public static func split<T: TensorFlowScalar>(
-  splitDim: Tensor<Int32>,
-  value: Tensor<T>,
-  numSplit: Int64
-) -> [Tensor<T>] {
-  let op = TFE_Op("Split")
-  op.setAttr("num_split", numSplit)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(splitDim)
-  let _ = op.addInput(value)
-  return op.execute(Int(numSplit))
-}
-
-/// Splits a tensor into `num_split` tensors along one dimension.
-///
-/// - Parameters:
-///   - value: The tensor to split.
-///   - size_splits: list containing the sizes of each output tensor along the split
-///     dimension. Must sum to the dimension of value along split_dim.
-///     Can contain one -1 indicating that dimension is to be inferred.
-///   - split_dim: 0-D.  The dimension along which to split.  Must be in the range
-///     `[-rank(value), rank(value))`.
-///
-/// - Output output: Tensors whose shape matches that of `value`
-///   except along `axis`, where their sizes are
-///   `size_splits[i]`.
-@inlinable
-public static func splitV<
-    T: TensorFlowScalar,
-    Tlen: BinaryInteger & TensorFlowScalar
->(
-  value: Tensor<T>,
-  sizeSplits: Tensor<Tlen>,
-  splitDim: Tensor<Int32>,
-  numSplit: Int64
-) -> [Tensor<T>] {
-  let op = TFE_Op("SplitV")
-  op.setAttr("num_split", numSplit)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tlen", Tlen.tensorFlowDataType)
-  let _ = op.addInput(value)
-  let _ = op.addInput(sizeSplits)
-  let _ = op.addInput(splitDim)
-  return op.execute(Int(numSplit))
-}
-
-/// Computes square root of x element-wise.
-///
-/// I.e., \\(y = \sqrt{x} = x^{1/2}\\).
-@inlinable
-public static func sqrt<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Sqrt")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient for the sqrt of `x` wrt its input.
-///
-/// Specifically, `grad = dy * 0.5 / y`, where `y = sqrt(x)`, and `dy`
-/// is the corresponding input gradient.
-@inlinable
-public static func sqrtGrad<T: FloatingPoint & TensorFlowScalar>(
-  _ y: Tensor<T>,
-  dy: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("SqrtGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(y)
-  let _ = op.addInput(dy)
-  return op.execute(Int(1))
-}
-
-/// Computes square of x element-wise.
-///
-/// I.e., \\(y = x * x = x^2\\).
-@inlinable
-public static func square<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Square")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Returns (x - y)(x - y) element-wise.
-///
-/// *NOTE*: `SquaredDifference` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func squaredDifference<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("SquaredDifference")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Removes dimensions of size 1 from the shape of a tensor.
-///
-/// Given a tensor `input`, this operation returns a tensor of the same type with
-/// all dimensions of size 1 removed. If you don't want to remove all size 1
-/// dimensions, you can remove specific size 1 dimensions by specifying
-/// `axis`.
-///
-/// For example:
-///
-/// ```
-/// # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
-/// shape(squeeze(t)) ==> [2, 3]
-/// ```
-///
-/// Or, to remove specific size 1 dimensions:
-///
-/// ```
-/// # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
-/// shape(squeeze(t, [2, 4])) ==> [1, 2, 3, 1]
-/// ```
-///
-/// - Parameter input: The `input` to squeeze.
-///
-/// - Attr squeeze_dims: If specified, only squeezes the dimensions listed. The dimension
-///   index starts at 0. It is an error to squeeze a dimension that is not 1. Must
-///   be in the range `[-rank(input), rank(input))`.
-///
-/// - Output output: Contains the same data as `input`, but has one or more dimensions of
-///   size 1 removed.
-@inlinable
-public static func squeeze<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  squeezeDims: [Int32]
-) -> Tensor<T> {
-  let op = TFE_Op("Squeeze")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("squeeze_dims", squeezeDims)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Delete the stack from its resource container.
-///
-/// - Parameter handle: The handle to a stack.
-@inlinable
-public static func stackCloseV2(
-  handle: ResourceHandle
-) {
-  let op = TFE_Op("StackCloseV2")
-  let _ = op.addInput(handle)
-  op.execute()
-}
-
-/// Pop the element at the top of the stack.
-///
-/// - Parameter handle: The handle to a stack.
-///
-/// - Attr elem_type: The type of the elem that is popped.
-///
-/// - Output elem: The tensor that is popped from the top of the stack.
-@inlinable
-public static func stackPopV2<ElemType: TensorFlowScalar>(
-  handle: ResourceHandle
-) -> Tensor<ElemType> {
-  let op = TFE_Op("StackPopV2")
-  op.setAttr("elem_type", ElemType.tensorFlowDataType)
-  let _ = op.addInput(handle)
-  return op.execute(Int(1))
-}
-
-/// Push an element onto the stack.
-///
-/// - Parameters:
-///   - handle: The handle to a stack.
-///   - elem: The tensor to be pushed onto the stack.
-///
-/// - Attr swap_memory: Swap `elem` to CPU. Default to false.
-///
-/// - Output output: The same tensor as the input 'elem'.
-@inlinable
-public static func stackPushV2<T: TensorFlowScalar>(
-  handle: ResourceHandle,
-  elem: Tensor<T>,
-  swapMemory: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("StackPushV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("swap_memory", swapMemory)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(elem)
-  return op.execute(Int(1))
-}
-
-/// A stack that produces elements in first-in last-out order.
-///
-/// - Parameter max_size: The maximum size of the stack if non-negative. If negative, the stack
-///   size is unlimited.
-///
-/// - Attrs:
-///   - elem_type: The type of the elements on the stack.
-///   - stack_name: Overrides the name used for the temporary stack resource. Default
-///     value is the name of the 'Stack' op (which is guaranteed unique).
-///
-/// - Output handle: The handle to the stack.
-@inlinable
-public static func stackV2(
-  maxSize: Tensor<Int32>,
-  elemType: TensorDataType,
-  stackName: String
-) -> ResourceHandle {
-  let op = TFE_Op("StackV2")
-  op.setAttr("elem_type", elemType)
-  op.setAttr("stack_name", stackName)
-  let _ = op.addInput(maxSize)
-  return op.execute(Int(1))
-}
-
-/// Stage values similar to a lightweight Enqueue.
-///
-/// The basic functionality of this Op is similar to a queue with many
-/// fewer capabilities and options.  This Op is optimized for performance.
-///
-/// - Parameter values: a list of tensors
-///   dtypes A list of data types that inserted values should adhere to.
-///
-/// - Attrs:
-///   - capacity: Maximum number of elements in the Staging Area. If > 0, inserts
-///     on the container will block when the capacity is reached.
-///   - memory_limit: The maximum number of bytes allowed for Tensors in the Staging Area.
-///     If > 0, inserts will block until sufficient space is available.
-///   - container: If non-empty, this queue is placed in the given container. Otherwise,
-///     a default container is used.
-///   - shared_name: It is necessary to match this name to the matching Unstage Op.
-@inlinable
-public static func stage<Dtypes: TensorArrayProtocol>(
-  _ values: Dtypes,
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  container: String,
-  sharedName: String
-) {
-  let op = TFE_Op("Stage")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", values._typeList)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInputList(values)
-  op.execute()
-}
-
-/// Op removes all elements in the underlying container.
-@inlinable
-public static func stageClear(
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  dtypes: [TensorDataType],
-  container: String,
-  sharedName: String
-) {
-  let op = TFE_Op("StageClear")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", dtypes)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.execute()
-}
-
-/// Op peeks at the values at the specified index.  If the
-///
-/// underlying container does not contain sufficient elements
-/// this op will block until it does.   This Op is optimized for
-/// performance.
-@inlinable
-public static func stagePeek<Dtypes: TensorGroup>(
-  index: Tensor<Int32>,
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  container: String,
-  sharedName: String
-) -> Dtypes {
-  let op = TFE_Op("StagePeek")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", Dtypes._typeList)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(index)
-  return op.execute(Int(Dtypes._typeList.count))
-}
-
-/// Op returns the number of elements in the underlying container.
-@inlinable
-public static func stageSize(
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  dtypes: [TensorDataType],
-  container: String,
-  sharedName: String
-) -> Tensor<Int32> {
-  let op = TFE_Op("StageSize")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", dtypes)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// returns `f(inputs)`, where `f`'s body is placed and partitioned.
-///
-/// - Parameter args: A list of input tensors.
-///
-/// - Attrs:
-///   - Tin: A list of input types.
-///   - Tout: A list of output types.
-///   - f:       A function that takes 'args', a list of tensors, and returns 'output',
-///           another list of tensors. Input and output types are specified by 'Tin'
-///           and 'Tout'. The function body of f will be placed and partitioned across
-///           devices, setting this op apart from the regular Call op. This op is
-///           stateful.
-///
-/// - Output output: A list of return values.
-@inlinable
-public static func statefulPartitionedCall<
-    Tin: TensorArrayProtocol,
-    Tout: TensorGroup,
-    FIn: TensorGroup,
-    FOut: TensorGroup
->(
-  args: Tin,
-  f: (FIn) -> FOut,
-  config: String,
-  configProto: String,
-  executorType: String
-) -> Tout {
-  let op = TFE_Op("StatefulPartitionedCall")
-  op.setAttr("Tin", args._typeList)
-  op.setAttr("Tout", Tout._typeList)
-  op.setAttr("f", f)
-  op.setAttr("config", config)
-  op.setAttr("config_proto", configProto)
-  op.setAttr("executor_type", executorType)
-  let _ = op.addInputList(args)
-  return op.execute(Int(Tout._typeList.count))
-}
-
-@inlinable
-public static func statefulRandomBinomial<
-    S: BinaryInteger & TensorFlowScalar,
-    T: Numeric & TensorFlowScalar,
-    Dtype: Numeric & TensorFlowScalar
->(
-  resource: ResourceHandle,
-  algorithm: Tensor<Int64>,
-  shape: Tensor<S>,
-  counts: Tensor<T>,
-  probs: Tensor<T>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("StatefulRandomBinomial")
-  op.setAttr("S", S.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(algorithm)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(counts)
-  let _ = op.addInput(probs)
-  return op.execute(Int(1))
-}
-
-/// Outputs random values from a normal distribution. This op is deprecated in favor of op 'StatefulStandardNormalV2'
-///
-/// The generated values will have mean 0 and standard deviation 1.
-///
-/// - Parameters:
-///   - resource: The handle of the resource variable that stores the state of the RNG.
-///   - shape: The shape of the output tensor.
-///
-/// - Attr dtype: The type of the output.
-///
-/// - Output output: A tensor of the specified shape filled with random normal values.
-@inlinable
-public static func statefulStandardNormal<
-    Dtype: TensorFlowScalar,
-    ShapeDtype: TensorFlowScalar
->(
-  resource: ResourceHandle,
-  shape: Tensor<ShapeDtype>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("StatefulStandardNormal")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Outputs random values from a normal distribution.
-///
-/// The generated values will have mean 0 and standard deviation 1.
-///
-/// - Parameters:
-///   - resource: The handle of the resource variable that stores the state of the RNG.
-///   - algorithm: The RNG algorithm.
-///   - shape: The shape of the output tensor.
-///
-/// - Attr dtype: The type of the output.
-///
-/// - Output output: A tensor of the specified shape filled with random normal values.
-@inlinable
-public static func statefulStandardNormalV2<
-    Dtype: TensorFlowScalar,
-    ShapeDtype: TensorFlowScalar
->(
-  resource: ResourceHandle,
-  algorithm: Tensor<Int64>,
-  shape: Tensor<ShapeDtype>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("StatefulStandardNormalV2")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(algorithm)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Outputs random values from a truncated normal distribution.
-///
-/// The generated values follow a normal distribution with mean 0 and standard
-/// deviation 1, except that values whose magnitude is more than 2 standard
-/// deviations from the mean are dropped and re-picked.
-///
-/// - Parameters:
-///   - resource: The handle of the resource variable that stores the state of the RNG.
-///   - algorithm: The RNG algorithm.
-///   - shape: The shape of the output tensor.
-///
-/// - Attr dtype: The type of the output.
-///
-/// - Output output: Random values with specified shape.
-@inlinable
-public static func statefulTruncatedNormal<
-    Dtype: TensorFlowScalar,
-    ShapeDtype: TensorFlowScalar
->(
-  resource: ResourceHandle,
-  algorithm: Tensor<Int64>,
-  shape: Tensor<ShapeDtype>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("StatefulTruncatedNormal")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(algorithm)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Outputs random values from a uniform distribution.
-///
-/// The generated values follow a uniform distribution in the range `[0, 1)`. The
-/// lower bound 0 is included in the range, while the upper bound 1 is excluded.
-///
-/// - Parameters:
-///   - resource: The handle of the resource variable that stores the state of the RNG.
-///   - algorithm: The RNG algorithm.
-///   - shape: The shape of the output tensor.
-///
-/// - Attr dtype: The type of the output.
-///
-/// - Output output: Random values with specified shape.
-@inlinable
-public static func statefulUniform<
-    Dtype: TensorFlowScalar,
-    ShapeDtype: TensorFlowScalar
->(
-  resource: ResourceHandle,
-  algorithm: Tensor<Int64>,
-  shape: Tensor<ShapeDtype>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("StatefulUniform")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(algorithm)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Outputs random integers from a uniform distribution.
-///
-/// The generated values are uniform integers covering the whole range of `dtype`. 
-///
-/// - Parameters:
-///   - resource: The handle of the resource variable that stores the state of the RNG.
-///   - algorithm: The RNG algorithm.
-///   - shape: The shape of the output tensor.
-///
-/// - Attr dtype: The type of the output.
-///
-/// - Output output: Random values with specified shape.
-@inlinable
-public static func statefulUniformFullInt<
-    Dtype: TensorFlowScalar,
-    ShapeDtype: TensorFlowScalar
->(
-  resource: ResourceHandle,
-  algorithm: Tensor<Int64>,
-  shape: Tensor<ShapeDtype>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("StatefulUniformFullInt")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(algorithm)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Outputs random integers from a uniform distribution.
-///
-/// The generated values are uniform integers in the range `[minval, maxval)`.
-/// The lower bound `minval` is included in the range, while the upper bound
-/// `maxval` is excluded.
-///
-/// The random integers are slightly biased unless `maxval - minval` is an exact
-/// power of two.  The bias is small for values of `maxval - minval` significantly
-/// smaller than the range of the output (either `2^32` or `2^64`).
-///
-/// - Parameters:
-///   - resource: The handle of the resource variable that stores the state of the RNG.
-///   - algorithm: The RNG algorithm.
-///   - shape: The shape of the output tensor.
-///   - minval: Minimum value (inclusive, scalar).
-///   - maxval: Maximum value (exclusive, scalar).
-///
-/// - Attr dtype: The type of the output.
-///
-/// - Output output: Random values with specified shape.
-@inlinable
-public static func statefulUniformInt<
-    Dtype: TensorFlowScalar,
-    ShapeDtype: TensorFlowScalar
->(
-  resource: ResourceHandle,
-  algorithm: Tensor<Int64>,
-  shape: Tensor<ShapeDtype>,
-  minval: Tensor<Dtype>,
-  maxval: Tensor<Dtype>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("StatefulUniformInt")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("shape_dtype", ShapeDtype.tensorFlowDataType)
-  let _ = op.addInput(resource)
-  let _ = op.addInput(algorithm)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(minval)
-  let _ = op.addInput(maxval)
-  return op.execute(Int(1))
-}
-
-/// output = cond ? then_branch(input) : else_branch(input)
-///
-/// - Parameters:
-///   - cond:       A Tensor. If the tensor is a scalar of non-boolean type, the
-///           scalar is converted to a boolean according to the
-///           following rule: if the scalar is a numerical value, non-zero means
-///           `True` and zero means False; if the scalar is a string, non-empty
-///           means `True` and empty means `False`. If the tensor is not a scalar,
-///           being empty means False and being non-empty means True.
-///
-///           This should only be used when the if then/else body functions do not
-///           have stateful ops.
-///   - input: A list of input tensors.
-///
-/// - Attrs:
-///   - Tin: A list of input types.
-///   - Tout: A list of output types.
-///   - then_branch:       A function that takes 'inputs' and returns a list of tensors, whose
-///           types are the same as what else_branch returns.
-///   - else_branch:     A function that takes 'inputs' and returns a list of tensors, whose
-///         types are the same as what then_branch returns.
-///
-/// - Output output: A list of return values.
-@inlinable
-public static func statelessIf<
-    Tcond: TensorFlowScalar,
-    Tin: TensorArrayProtocol,
-    Tout: TensorGroup,
-    ThenbranchIn: TensorGroup,
-    ThenbranchOut: TensorGroup,
-    ElsebranchIn: TensorGroup,
-    ElsebranchOut: TensorGroup
->(
-  cond: Tensor<Tcond>,
-  _ input: Tin,
-  thenBranch: (ThenbranchIn) -> ThenbranchOut,
-  elseBranch: (ElsebranchIn) -> ElsebranchOut
-) -> Tout {
-  let op = TFE_Op("StatelessIf")
-  op.setAttr("Tcond", Tcond.tensorFlowDataType)
-  op.setAttr("Tin", input._typeList)
-  op.setAttr("Tout", Tout._typeList)
-  op.setAttr("then_branch", thenBranch)
-  op.setAttr("else_branch", elseBranch)
-  let _ = op.addInput(cond)
-  let _ = op.addInputList(input)
-  return op.execute(Int(Tout._typeList.count))
-}
-
-/// Draws samples from a multinomial distribution.
-///
-/// - Parameters:
-///   - logits: 2-D Tensor with shape `[batch_size, num_classes]`.  Each slice `[i, :]`
-///     represents the unnormalized log probabilities for all classes.
-///   - num_samples: 0-D.  Number of independent samples to draw for each row slice.
-///   - seed: 2 seeds (shape [2]).
-///
-/// - Output output: 2-D Tensor with shape `[batch_size, num_samples]`.  Each slice `[i, :]`
-///   contains the drawn class labels with range `[0, num_classes)`.
-@inlinable
-public static func statelessMultinomial<
-    T: Numeric & TensorFlowScalar,
-    Tseed: BinaryInteger & TensorFlowScalar,
-    OutputDtype: BinaryInteger & TensorFlowScalar
->(
-  logits: Tensor<T>,
-  numSamples: Tensor<Int32>,
-  seed: Tensor<Tseed>
-) -> Tensor<OutputDtype> {
-  let op = TFE_Op("StatelessMultinomial")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tseed", Tseed.tensorFlowDataType)
-  op.setAttr("output_dtype", OutputDtype.tensorFlowDataType)
-  let _ = op.addInput(logits)
-  let _ = op.addInput(numSamples)
-  let _ = op.addInput(seed)
-  return op.execute(Int(1))
-}
-
-/// Outputs deterministic pseudorandom values from a normal distribution.
-///
-/// The generated values will have mean 0 and standard deviation 1.
-///
-/// The outputs are a deterministic function of `shape` and `seed`.
-///
-/// - Parameters:
-///   - shape: The shape of the output tensor.
-///   - seed: 2 seeds (shape [2]).
-///
-/// - Attr dtype: The type of the output.
-///
-/// - Output output: Random values with specified shape.
-@inlinable
-public static func statelessRandomNormal<
-    Dtype: FloatingPoint & TensorFlowScalar,
-    T: BinaryInteger & TensorFlowScalar,
-    Tseed: BinaryInteger & TensorFlowScalar
->(
-  shape: Tensor<T>,
-  seed: Tensor<Tseed>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("StatelessRandomNormal")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tseed", Tseed.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(seed)
-  return op.execute(Int(1))
-}
-
-/// Outputs deterministic pseudorandom random values from a uniform distribution.
-///
-/// The generated values follow a uniform distribution in the range `[0, 1)`. The
-/// lower bound 0 is included in the range, while the upper bound 1 is excluded.
-///
-/// The outputs are a deterministic function of `shape` and `seed`.
-///
-/// - Parameters:
-///   - shape: The shape of the output tensor.
-///   - seed: 2 seeds (shape [2]).
-///
-/// - Attr dtype: The type of the output.
-///
-/// - Output output: Random values with specified shape.
-@inlinable
-public static func statelessRandomUniform<
-    Dtype: FloatingPoint & TensorFlowScalar,
-    T: BinaryInteger & TensorFlowScalar,
-    Tseed: BinaryInteger & TensorFlowScalar
->(
-  shape: Tensor<T>,
-  seed: Tensor<Tseed>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("StatelessRandomUniform")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tseed", Tseed.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(seed)
-  return op.execute(Int(1))
-}
-
-/// Outputs deterministic pseudorandom random integers from a uniform distribution.
-///
-/// The generated values follow a uniform distribution in the range `[minval, maxval)`.
-///
-/// The outputs are a deterministic function of `shape`, `seed`, `minval`, and `maxval`.
-///
-/// - Parameters:
-///   - shape: The shape of the output tensor.
-///   - seed: 2 seeds (shape [2]).
-///   - minval: Minimum value (inclusive, scalar).
-///   - maxval: Maximum value (exclusive, scalar).
-///
-/// - Attr dtype: The type of the output.
-///
-/// - Output output: Random values with specified shape.
-@inlinable
-public static func statelessRandomUniformInt<
-    Dtype: BinaryInteger & TensorFlowScalar,
-    T: BinaryInteger & TensorFlowScalar,
-    Tseed: BinaryInteger & TensorFlowScalar
->(
-  shape: Tensor<T>,
-  seed: Tensor<Tseed>,
-  minval: Tensor<Dtype>,
-  maxval: Tensor<Dtype>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("StatelessRandomUniformInt")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tseed", Tseed.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(seed)
-  let _ = op.addInput(minval)
-  let _ = op.addInput(maxval)
-  return op.execute(Int(1))
-}
-
-/// Outputs deterministic pseudorandom values from a truncated normal distribution.
-///
-/// The generated values follow a normal distribution with mean 0 and standard
-/// deviation 1, except that values whose magnitude is more than 2 standard
-/// deviations from the mean are dropped and re-picked.
-///
-/// The outputs are a deterministic function of `shape` and `seed`.
-///
-/// - Parameters:
-///   - shape: The shape of the output tensor.
-///   - seed: 2 seeds (shape [2]).
-///
-/// - Attr dtype: The type of the output.
-///
-/// - Output output: Random values with specified shape.
-@inlinable
-public static func statelessTruncatedNormal<
-    Dtype: FloatingPoint & TensorFlowScalar,
-    T: BinaryInteger & TensorFlowScalar,
-    Tseed: BinaryInteger & TensorFlowScalar
->(
-  shape: Tensor<T>,
-  seed: Tensor<Tseed>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("StatelessTruncatedNormal")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tseed", Tseed.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(seed)
-  return op.execute(Int(1))
-}
-
-/// output = input; While (Cond(output)) { output = Body(output) }
-///
-/// - Parameter input: A list of input tensors whose types are T.
-///
-/// - Attrs:
-///   - T: dtype in use.
-///   - cond:       A function takes 'input' and returns a tensor.  If the tensor is
-///           a scalar of non-boolean, the scalar is converted to a boolean
-///           according to the following rule: if the scalar is a numerical
-///           value, non-zero means True and zero means False; if the scalar is
-///           a string, non-empty means True and empty means False. If the
-///           tensor is not a scalar, non-emptiness means True and False
-///           otherwise.
-///
-///           This should only be used when the while condition and body functions
-///           do not have stateful ops.
-///   - body:       A function that takes a list of tensors and returns another
-///           list of tensors. Both lists have the same types as specified
-///           by T.
-///
-/// - Output output: A list of output tensors whose types are T.
-@inlinable
-public static func statelessWhile<
-    T: TensorArrayProtocol,
-    CondIn: TensorGroup,
-    CondOut: TensorGroup,
-    BodyIn: TensorGroup,
-    BodyOut: TensorGroup
->(
-  _ input: T,
-  cond: (CondIn) -> CondOut,
-  body: (BodyIn) -> BodyOut
-) -> T {
-  let op = TFE_Op("StatelessWhile")
-  op.setAttr("T", input._typeList)
-  op.setAttr("cond", cond)
-  op.setAttr("body", body)
-  let _ = op.addInputList(input)
-  return op.execute(Int(input._typeList.count))
-}
-
-/// Check if the input matches the regex pattern.
-///
-/// The input is a string tensor of any shape. The pattern is the
-/// regular expression to be matched with every element of the input tensor.
-/// The boolean values (True or False) of the output tensor indicate
-/// if the input matches the regex pattern provided.
-///
-/// The pattern follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
-///
-/// - Parameter input: A string tensor of the text to be processed.
-///
-/// - Attr pattern: The regular expression to match the input.
-///
-/// - Output output: A bool tensor with the same shape as `input`.
-@inlinable
-public static func staticRegexFullMatch(
-  _ input: StringTensor,
-  pattern: String
-) -> Tensor<Bool> {
-  let op = TFE_Op("StaticRegexFullMatch")
-  op.setAttr("pattern", pattern)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Replaces the match of pattern in input with rewrite.
-///
-/// It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
-///
-/// - Parameter input: The text to be processed.
-///
-/// - Attrs:
-///   - pattern: The regular expression to match the input.
-///   - rewrite: The rewrite to be applied to the matched expression.
-///   - replace_global: If True, the replacement is global, otherwise the replacement
-///     is done only on the first match.
-///
-/// - Output output: The text after applying pattern and rewrite.
-@inlinable
-public static func staticRegexReplace(
-  _ input: StringTensor,
-  pattern: String,
-  rewrite: String,
-  replaceGlobal: Bool = true
-) -> StringTensor {
-  let op = TFE_Op("StaticRegexReplace")
-  op.setAttr("pattern", pattern)
-  op.setAttr("rewrite", rewrite)
-  op.setAttr("replace_global", replaceGlobal)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func statsAggregatorHandleV2(
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("StatsAggregatorHandleV2")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Set a summary_writer_interface to record statistics using given stats_aggregator.
-@inlinable
-public static func statsAggregatorSetSummaryWriter(
-  statsAggregator: ResourceHandle,
-  summary: ResourceHandle
-) {
-  let op = TFE_Op("StatsAggregatorSetSummaryWriter")
-  let _ = op.addInput(statsAggregator)
-  let _ = op.addInput(summary)
-  op.execute()
-}
-
-/// 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.
-@inlinable
-public static func stopGradient<T: TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("StopGradient")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Return a strided slice from `input`.
-///
-/// Note, most python users will want to use the Python `Tensor.__getitem__`
-/// or `Variable.__getitem__` rather than this op directly.
-///
-/// The goal of this op is to produce a new tensor with a subset of
-/// the elements from the `n` dimensional `input` tensor. The subset is chosen using
-/// a sequence of `m` sparse range specifications encoded into the arguments
-/// of this function. Note, in some cases
-/// `m` could be equal to `n`, but this need not be the case. Each
-/// range specification entry can be one of the following:
-///
-/// - An ellipsis (...). Ellipses are used to imply zero or more
-///   dimensions of full-dimension selection and are produced using
-///   `ellipsis_mask`. For example, `foo[...]` is the identity slice.
-///
-/// - A new axis. This is used to insert a new shape=1 dimension and is
-///   produced using `new_axis_mask`. For example, `foo[:, ...]` where
-///   `foo` is shape `(3, 4)` produces a `(1, 3, 4)` tensor.
-///
-///
-/// - A range `begin:end:stride`. This is used to specify how much to choose from
-///   a given dimension. `stride` can be any integer but 0.  `begin` is an integer
-///   which represents the index of the first value to select while `end` represents
-///   the index of the last value to select. The number of values selected in each
-///   dimension is `end - begin` if `stride > 0` and `begin - end` if `stride < 0`.
-///   `begin` and `end` can be negative where `-1` is the last element, `-2` is
-///   the second to last. `begin_mask` controls whether to replace the explicitly
-///   given `begin` with an implicit effective value of `0` if `stride > 0` and
-///   `-1` if `stride < 0`. `end_mask` is analogous but produces the number
-///   required to create the largest open interval. For example, given a shape
-///   `(3,)` tensor `foo[:]`, the effective `begin` and `end` are `0` and `3`. Do
-///   not assume this is equivalent to `foo[0:-1]` which has an effective `begin`
-///   and `end` of `0` and `2`. Another example is `foo[-2::-1]` which reverses the
-///   first dimension of a tensor while dropping the last two (in the original
-///   order elements). For example `foo = [1,2,3,4]; foo[-2::-1]` is `[4,3]`.
-///
-/// - A single index. This is used to keep only elements that have a given
-///   index. For example (`foo[2, :]` on a shape `(5,6)` tensor produces a
-///   shape `(6,)` tensor. This is encoded in `begin` and `end` and
-///   `shrink_axis_mask`.
-///
-/// Each conceptual range specification is encoded in the op's argument. This
-/// encoding is best understand by considering a non-trivial example. In
-/// particular,
-/// `foo[1, 2:4, None, ..., :-3:-1, :]` will be encoded as
-///
-/// ```
-/// begin = [1, 2, x, x, 0, x] # x denotes don't care (usually 0)
-/// end = [2, 4, x, x, -3, x]
-/// strides = [1, 1, x, x, -1, 1]
-/// begin_mask = 1<<4 | 1 << 5 = 48
-/// end_mask = 1<<5 = 32
-/// ellipsis_mask = 1<<3 = 8
-/// new_axis_mask = 1<<2 4
-/// shrink_axis_mask = 1<<0
-/// ```
-///
-/// In this case if `foo.shape` is (5, 5, 5, 5, 5, 5) the final shape of
-/// the slice becomes (2, 1, 5, 5, 2, 5).
-/// Let us walk step by step through each argument specification.
-///
-/// 1.  The first argument in the example slice is turned into `begin = 1` and
-/// `end = begin + 1 = 2`. To disambiguate from the original spec `2:4` we
-/// also set the appropriate bit in `shrink_axis_mask`.
-///
-/// 2. `2:4` is contributes 2, 4, 1 to begin, end, and stride. All masks have
-/// zero bits contributed.
-///
-/// 3. None is a synonym for `tf.newaxis`. This means insert a dimension of size 1
-/// dimension in the final shape. Dummy values are contributed to begin,
-/// end and stride, while the new_axis_mask bit is set.
-///
-/// 4. `...` grab the full ranges from as many dimensions as needed to
-/// fully specify a slice for every dimension of the input shape.
-///
-/// 5. `:-3:-1` shows the use of negative indices. A negative index `i` associated
-/// with a dimension that has shape `s` is converted to a positive index
-/// `s + i`. So `-1` becomes `s-1` (i.e. the last element). This conversion
-/// is done internally so begin, end and strides receive x, -3, and -1.
-/// The appropriate begin_mask bit is set to indicate the start range is the
-/// full range (ignoring the x).
-///
-/// 6. `:` indicates that the entire contents of the corresponding dimension
-/// is selected. This is equivalent to `::` or `0::1`. begin, end, and strides
-/// receive 0, 0, and 1, respectively. The appropriate bits in `begin_mask` and
-/// `end_mask` are also set.
-///
-/// *Requirements*:
-///   `0 != strides[i] for i in [0, m)`
-///   `ellipsis_mask must be a power of two (only one ellipsis)`
-///
-/// - Parameters:
-///   - begin: `begin[k]` specifies the offset into the `k`th range specification.
-///     The exact dimension this corresponds to will be determined by context.
-///     Out-of-bounds values will be silently clamped. If the `k`th bit of
-///     `begin_mask` then `begin[k]` is ignored and the full range of the
-///     appropriate dimension is used instead. Negative values causes indexing
-///     to start from the highest element e.g. If `foo==[1,2,3]` then `foo[-1]==3`.
-///   - end: `end[i]` is like `begin` with the exception that `end_mask` is
-///     used to determine full ranges.
-///   - strides: `strides[i]` specifies the increment in the `i`th specification
-///     after extracting a given element. Negative indices will reverse
-///     the original order. Out or range values are
-///     clamped to `[0,dim[i]) if slice[i]>0` or `[-1,dim[i]-1] if slice[i] < 0`
-///
-/// - Attrs:
-///   - begin_mask: a bitmask where a bit i being 1 means to ignore the begin
-///     value and instead use the largest interval possible. At runtime
-///     begin[i] will be replaced with `[0, n-1)` if `stride[i] > 0` or
-///     `[-1, n-1]` if `stride[i] < 0`
-///   - end_mask: analogous to `begin_mask`
-///   - ellipsis_mask: a bitmask where bit `i` being 1 means the `i`th
-///     position is actually an ellipsis. One bit at most can be 1.
-///     If `ellipsis_mask == 0`, then an implicit ellipsis mask of `1 << (m+1)`
-///     is provided. This means that `foo[3:5] == foo[3:5, ...]`. An ellipsis
-///     implicitly creates as many range specifications as necessary to fully
-///     specify the sliced range for every dimension. For example for a 4-dimensional
-///     tensor `foo` the slice `foo[2, ..., 5:8]` implies `foo[2, :, :, 5:8]`.
-///   - new_axis_mask: a bitmask where bit `i` being 1 means the `i`th
-///     specification creates a new shape 1 dimension. For example
-///     `foo[:4, tf.newaxis, :2]` would produce a shape `(4, 1, 2)` tensor.
-///   - shrink_axis_mask: a bitmask where bit `i` implies that the `i`th
-///     specification should shrink the dimensionality. begin and end
-///     must imply a slice of size 1 in the dimension. For example in
-///     python one might do `foo[:, 3, :]` which would result in
-///     `shrink_axis_mask` being 2.
-@inlinable
-public static func stridedSlice<
-    T: TensorFlowScalar,
-    Index: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  begin: Tensor<Index>,
-  end: Tensor<Index>,
-  strides: Tensor<Index>,
-  beginMask: Int64 = 0,
-  endMask: Int64 = 0,
-  ellipsisMask: Int64 = 0,
-  newAxisMask: Int64 = 0,
-  shrinkAxisMask: Int64 = 0
-) -> Tensor<T> {
-  let op = TFE_Op("StridedSlice")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Index", Index.tensorFlowDataType)
-  op.setAttr("begin_mask", beginMask)
-  op.setAttr("end_mask", endMask)
-  op.setAttr("ellipsis_mask", ellipsisMask)
-  op.setAttr("new_axis_mask", newAxisMask)
-  op.setAttr("shrink_axis_mask", shrinkAxisMask)
-  let _ = op.addInput(input)
-  let _ = op.addInput(begin)
-  let _ = op.addInput(end)
-  let _ = op.addInput(strides)
-  return op.execute(Int(1))
-}
-
-/// Returns the gradient of `StridedSlice`.
-///
-/// Since `StridedSlice` cuts out pieces of its `input` which is size
-/// `shape`, its gradient will have the same shape (which is passed here
-/// as `shape`). The gradient will be zero in any element that the slice
-/// does not select.
-///
-/// Arguments are the same as StridedSliceGrad with the exception that
-/// `dy` is the input gradient to be propagated and `shape` is the
-/// shape of `StridedSlice`'s `input`.
-@inlinable
-public static func stridedSliceGrad<
-    T: TensorFlowScalar,
-    Index: BinaryInteger & TensorFlowScalar
->(
-  shape: Tensor<Index>,
-  begin: Tensor<Index>,
-  end: Tensor<Index>,
-  strides: Tensor<Index>,
-  dy: Tensor<T>,
-  beginMask: Int64 = 0,
-  endMask: Int64 = 0,
-  ellipsisMask: Int64 = 0,
-  newAxisMask: Int64 = 0,
-  shrinkAxisMask: Int64 = 0
-) -> Tensor<T> {
-  let op = TFE_Op("StridedSliceGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Index", Index.tensorFlowDataType)
-  op.setAttr("begin_mask", beginMask)
-  op.setAttr("end_mask", endMask)
-  op.setAttr("ellipsis_mask", ellipsisMask)
-  op.setAttr("new_axis_mask", newAxisMask)
-  op.setAttr("shrink_axis_mask", shrinkAxisMask)
-  let _ = op.addInput(shape)
-  let _ = op.addInput(begin)
-  let _ = op.addInput(end)
-  let _ = op.addInput(strides)
-  let _ = op.addInput(dy)
-  return op.execute(Int(1))
-}
-
-/// Formats a string template using a list of tensors.
-///
-/// Formats a string template using a list of tensors, pretty-printing tensor summaries.
-///
-/// - Parameter inputs: The list of tensors to format into the placeholder string.
-///
-/// - Attrs:
-///   - template: A string, the template to format tensor summaries into.
-///   - placeholder: A string, at each placeholder in the template a subsequent tensor summary will be inserted.
-///   - summarize: When formatting the tensor summaries print the first and last summarize entries of each tensor dimension.
-///
-/// - Output output: = The resulting string scalar.
-@inlinable
-public static func stringFormat<T: TensorArrayProtocol>(
-  inputs: T,
-  template: String = "%s",
-  placeholder: String = "%s",
-  summarize: Int64 = 3
-) -> StringTensor {
-  let op = TFE_Op("StringFormat")
-  op.setAttr("T", inputs._typeList)
-  op.setAttr("template", template)
-  op.setAttr("placeholder", placeholder)
-  op.setAttr("summarize", summarize)
-  let _ = op.addInputList(inputs)
-  return op.execute(Int(1))
-}
-
-/// Joins the strings in the given list of string tensors into one tensor;
-///
-/// with the given separator (default is an empty separator).
-///
-/// - Parameter inputs: A list of string tensors.  The tensors must all have the same shape,
-///   or be scalars.  Scalars may be mixed in; these will be broadcast to the shape
-///   of non-scalar inputs.
-///
-/// - Attr separator: string, an optional join separator.
-@inlinable
-public static func stringJoin(
-  inputs: [StringTensor],
-  separator: String
-) -> StringTensor {
-  let op = TFE_Op("StringJoin")
-  op.setAttr("N", inputs.count)
-  op.setAttr("separator", separator)
-  let _ = op.addInputList(inputs)
-  return op.execute(Int(1))
-}
-
-/// String lengths of `input`.
-///
-/// Computes the length of each string given in the input tensor.
-///
-/// - Parameter input: The string for which to compute the length.
-///
-/// - Attr unit: The unit that is counted to compute string length.  One of: `"BYTE"` (for
-///   the number of bytes in each string) or `"UTF8_CHAR"` (for the number of UTF-8
-///   encoded Unicode code points in each string).  Results are undefined
-///   if `unit=UTF8_CHAR` and the `input` strings do not contain structurally
-///   valid UTF-8.
-///
-/// - Output output: Integer tensor that has the same shape as `input`. The output contains the
-///   element-wise string lengths of `input`.
-@inlinable
-public static func stringLength(
-  _ input: StringTensor,
-  unit: Unit = .byte
-) -> Tensor<Int32> {
-  let op = TFE_Op("StringLength")
-  op.setAttr("unit", unit.cName)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func stringListAttr(
-  _ a: [String],
-  _ b: String
-) {
-  let op = TFE_Op("StringListAttr")
-  op.setAttr("a", a)
-  op.setAttr("b", b)
-  op.execute()
-}
-
-/// Split elements of `input` based on `delimiter` into a `SparseTensor`.
-///
-/// Let N be the size of source (typically N will be the batch size). Split each
-/// element of `input` based on `delimiter` and return a `SparseTensor`
-/// containing the splitted tokens. Empty tokens are ignored.
-///
-/// `delimiter` can be empty, or a string of split characters. If `delimiter` is an
-///  empty string, each element of `input` is split into individual single-byte
-///  character strings, including splitting of UTF-8 multibyte sequences. Otherwise
-///  every character of `delimiter` is a potential split point.
-///
-/// For example:
-///   N = 2, input[0] is 'hello world' and input[1] is 'a b c', then the output
-///   will be
-///
-///   indices = [0, 0;
-///              0, 1;
-///              1, 0;
-///              1, 1;
-///              1, 2]
-///   shape = [2, 3]
-///   values = ['hello', 'world', 'a', 'b', 'c']
-///
-/// - Parameters:
-///   - input: 1-D. Strings to split.
-///   - delimiter: 0-D. Delimiter characters (bytes), or empty string.
-///
-/// - Attr skip_empty: A `bool`. If `True`, skip the empty strings from the result.
-///
-/// - Outputs:
-///   - indices: A dense matrix of int64 representing the indices of the sparse tensor.
-///   - values: A vector of strings corresponding to the splited values.
-///   - shape: a length-2 vector of int64 representing the shape of the sparse
-///     tensor, where the first value is N and the second value is the maximum number
-///     of tokens in a single input entry.
-@inlinable
-public static func stringSplit(
-  _ input: StringTensor,
-  delimiter: StringTensor,
-  skipEmpty: Bool = true
-) -> (indices: Tensor<Int64>, values: StringTensor, shape: Tensor<Int64>) {
-  let op = TFE_Op("StringSplit")
-  op.setAttr("skip_empty", skipEmpty)
-  let _ = op.addInput(input)
-  let _ = op.addInput(delimiter)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Split elements of `source` based on `sep` into a `SparseTensor`.
-///
-/// Let N be the size of source (typically N will be the batch size). Split each
-/// element of `source` based on `sep` and return a `SparseTensor`
-/// containing the split tokens. Empty tokens are ignored.
-///
-/// For example, N = 2, source[0] is 'hello world' and source[1] is 'a b c',
-/// then the output will be
-/// ```
-/// st.indices = [0, 0;
-///               0, 1;
-///               1, 0;
-///               1, 1;
-///               1, 2]
-/// st.shape = [2, 3]
-/// st.values = ['hello', 'world', 'a', 'b', 'c']
-/// ```
-///
-/// If `sep` is given, consecutive delimiters are not grouped together and are
-/// deemed to delimit empty strings. For example, source of `"1<>2<><>3"` and
-/// sep of `"<>"` returns `["1", "2", "", "3"]`. If `sep` is None or an empty
-/// string, consecutive whitespace are regarded as a single separator, and the
-/// result will contain no empty strings at the startor end if the string has
-/// leading or trailing whitespace.
-///
-/// Note that the above mentioned behavior matches python's str.split.
-///
-/// - Parameters:
-///   - input: `1-D` string `Tensor`, the strings to split.
-///   - sep: `0-D` string `Tensor`, the delimiter character.
-///
-/// - Attr maxsplit: An `int`. If `maxsplit > 0`, limit of the split of the result.
-@inlinable
-public static func stringSplitV2(
-  _ input: StringTensor,
-  sep: StringTensor,
-  maxsplit: Int64 = -1
-) -> (indices: Tensor<Int64>, values: StringTensor, shape: Tensor<Int64>) {
-  let op = TFE_Op("StringSplitV2")
-  op.setAttr("maxsplit", maxsplit)
-  let _ = op.addInput(input)
-  let _ = op.addInput(sep)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Strip leading and trailing whitespaces from the Tensor.
-///
-/// - Parameter input: A string `Tensor` of any shape.
-///
-/// - Output output: A string `Tensor` of the same shape as the input.
-@inlinable
-public static func stringStrip(
-  _ input: StringTensor
-) -> StringTensor {
-  let op = TFE_Op("StringStrip")
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Converts each string in the input Tensor to its hash mod by a number of buckets.
-///
-/// The hash function is deterministic on the content of the string within the
-/// process.
-///
-/// Note that the hash function may change from time to time.
-/// This functionality will be deprecated and it's recommended to use
-/// `tf.string_to_hash_bucket_fast()` or `tf.string_to_hash_bucket_strong()`.
-///
-/// - Attr num_buckets: The number of buckets.
-///
-/// - Output output: A Tensor of the same shape as the input `string_tensor`.
-@inlinable
-public static func stringToHashBucket(
-  stringTensor: StringTensor,
-  numBuckets: Int64
-) -> Tensor<Int64> {
-  let op = TFE_Op("StringToHashBucket")
-  op.setAttr("num_buckets", numBuckets)
-  let _ = op.addInput(stringTensor)
-  return op.execute(Int(1))
-}
-
-/// Converts each string in the input Tensor to its hash mod by a number of buckets.
-///
-/// The hash function is deterministic on the content of the string within the
-/// process and will never change. However, it is not suitable for cryptography.
-/// This function may be used when CPU time is scarce and inputs are trusted or
-/// unimportant. There is a risk of adversaries constructing inputs that all hash
-/// to the same bucket. To prevent this problem, use a strong hash function with
-/// `tf.string_to_hash_bucket_strong`.
-///
-/// - Parameter input: The strings to assign a hash bucket.
-///
-/// - Attr num_buckets: The number of buckets.
-///
-/// - Output output: A Tensor of the same shape as the input `string_tensor`.
-@inlinable
-public static func stringToHashBucketFast(
-  _ input: StringTensor,
-  numBuckets: Int64
-) -> Tensor<Int64> {
-  let op = TFE_Op("StringToHashBucketFast")
-  op.setAttr("num_buckets", numBuckets)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Converts each string in the input Tensor to its hash mod by a number of buckets.
-///
-/// The hash function is deterministic on the content of the string within the
-/// process. The hash function is a keyed hash function, where attribute `key`
-/// defines the key of the hash function. `key` is an array of 2 elements.
-///
-/// A strong hash is important when inputs may be malicious, e.g. URLs with
-/// additional components. Adversaries could try to make their inputs hash to the
-/// same bucket for a denial-of-service attack or to skew the results. A strong
-/// hash prevents this by making it difficult, if not infeasible, to compute inputs
-/// that hash to the same bucket. This comes at a cost of roughly 4x higher compute
-/// time than `tf.string_to_hash_bucket_fast`.
-///
-/// - Parameter input: The strings to assign a hash bucket.
-///
-/// - Attrs:
-///   - num_buckets: The number of buckets.
-///   - key: The key for the keyed hash function passed as a list of two uint64
-///     elements.
-///
-/// - Output output: A Tensor of the same shape as the input `string_tensor`.
-@inlinable
-public static func stringToHashBucketStrong(
-  _ input: StringTensor,
-  numBuckets: Int64,
-  key: [Int32]
-) -> Tensor<Int64> {
-  let op = TFE_Op("StringToHashBucketStrong")
-  op.setAttr("num_buckets", numBuckets)
-  op.setAttr("key", key)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Converts each string in the input Tensor to the specified numeric type.
-///
-/// (Note that int32 overflow results in an error while float overflow
-/// results in a rounded value.)
-///
-/// - Attr out_type: The numeric type to interpret each string in `string_tensor` as.
-///
-/// - Output output: A Tensor of the same shape as the input `string_tensor`.
-@inlinable
-public static func stringToNumber<OutType: Numeric & TensorFlowScalar>(
-  stringTensor: StringTensor
-) -> Tensor<OutType> {
-  let op = TFE_Op("StringToNumber")
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(stringTensor)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func stubResourceHandleOp(
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("StubResourceHandleOp")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Returns x - y element-wise.
-///
-/// *NOTE*: `Subtract` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func sub<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Sub")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Return substrings from `Tensor` of strings.
-///
-/// For each string in the input `Tensor`, creates a substring starting at index
-/// `pos` with a total length of `len`.
-///
-/// If `len` defines a substring that would extend beyond the length of the input
-/// string, then as many characters as possible are used.
-///
-/// A negative `pos` indicates distance within the string backwards from the end.
-///
-/// If `pos` specifies an index which is out of range for any of the input strings,
-/// then an `InvalidArgumentError` is thrown.
-///
-/// `pos` and `len` must have the same shape, otherwise a `ValueError` is thrown on
-/// Op creation.
-///
-/// *NOTE*: `Substr` supports broadcasting up to two dimensions. More about
-/// broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-///
-/// ---
-///
-/// Examples
-///
-/// Using scalar `pos` and `len`:
-///
-/// ```python
-/// input = [b'Hello', b'World']
-/// position = 1
-/// length = 3
-///
-/// output = [b'ell', b'orl']
-/// ```
-///
-/// Using `pos` and `len` with same shape as `input`:
-///
-/// ```python
-/// input = [[b'ten', b'eleven', b'twelve'],
-///          [b'thirteen', b'fourteen', b'fifteen'],
-///          [b'sixteen', b'seventeen', b'eighteen']]
-/// position = [[1, 2, 3],
-///             [1, 2, 3],
-///             [1, 2, 3]]
-/// length =   [[2, 3, 4],
-///             [4, 3, 2],
-///             [5, 5, 5]]
-///
-/// output = [[b'en', b'eve', b'lve'],
-///           [b'hirt', b'urt', b'te'],
-///           [b'ixtee', b'vente', b'hteen']]
-/// ```
-///
-/// Broadcasting `pos` and `len` onto `input`:
-///
-/// ```
-/// input = [[b'ten', b'eleven', b'twelve'],
-///          [b'thirteen', b'fourteen', b'fifteen'],
-///          [b'sixteen', b'seventeen', b'eighteen'],
-///          [b'nineteen', b'twenty', b'twentyone']]
-/// position = [1, 2, 3]
-/// length =   [1, 2, 3]
-///
-/// output = [[b'e', b'ev', b'lve'],
-///           [b'h', b'ur', b'tee'],
-///           [b'i', b've', b'hte'],
-///           [b'i', b'en', b'nty']]
-/// ```
-///
-/// Broadcasting `input` onto `pos` and `len`:
-///
-/// ```
-/// input = b'thirteen'
-/// position = [1, 5, 7]
-/// length =   [3, 2, 1]
-///
-/// output = [b'hir', b'ee', b'n']
-/// ```
-///
-/// - Parameters:
-///   - input: Tensor of strings
-///   - pos: Scalar defining the position of first character in each substring
-///   - len: Scalar defining the number of characters to include in each substring
-///
-/// - Attr unit: The unit that is used to create the substring.  One of: `"BYTE"` (for
-///   defining position and length by bytes) or `"UTF8_CHAR"` (for the UTF-8
-///   encoded Unicode code points).  The default is `"BYTE"`. Results are undefined if
-///   `unit=UTF8_CHAR` and the `input` strings do not contain structurally valid
-///   UTF-8.
-///
-/// - Output output: Tensor of substrings
-@inlinable
-public static func substr<T: BinaryInteger & TensorFlowScalar>(
-  _ input: StringTensor,
-  pos: Tensor<T>,
-  len: Tensor<T>,
-  unit: Unit = .byte
-) -> StringTensor {
-  let op = TFE_Op("Substr")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("unit", unit.cName)
-  let _ = op.addInput(input)
-  let _ = op.addInput(pos)
-  let _ = op.addInput(len)
-  return op.execute(Int(1))
-}
-
-/// Computes the sum of elements across dimensions of a tensor.
-///
-/// Reduces `input` along the dimensions given in `axis`. Unless
-/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
-/// `axis`. If `keep_dims` is true, the reduced dimensions are
-/// retained with length 1.
-///
-/// - Parameters:
-///   - input: The tensor to reduce.
-///   - reduction_indices: The dimensions to reduce. Must be in the range
-///     `[-rank(input), rank(input))`.
-///
-/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
-///
-/// - Output output: The reduced tensor.
-@inlinable
-public static func sum<
-    T: Numeric & TensorFlowScalar,
-    Tidx: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  reductionIndices: Tensor<Tidx>,
-  keepDims: Bool = false
-) -> Tensor<T> {
-  let op = TFE_Op("Sum")
-  op.setAttr("keep_dims", keepDims)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(reductionIndices)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func summaryWriter(
-  sharedName: String,
-  container: String
-) -> ResourceHandle {
-  let op = TFE_Op("SummaryWriter")
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("container", container)
-  return op.execute(Int(1))
-}
-
-/// Computes the singular value decompositions of one or more matrices.
-///
-/// Computes the SVD of each inner matrix in `input` such that
-/// `input[..., :, :] = u[..., :, :] * diag(s[..., :, :]) * transpose(v[..., :, :])`
-///
-/// ```python
-/// # a is a tensor containing a batch of matrices.
-/// # s is a tensor of singular values for each matrix.
-/// # u is the tensor containing of left singular vectors for each matrix.
-/// # v is the tensor containing of right singular vectors for each matrix.
-/// s, u, v = svd(a)
-/// s, _, _ = svd(a, compute_uv=False)
-/// ```
-///
-/// - Parameter input: A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
-///   form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
-///
-/// - Attrs:
-///   - compute_uv: If true, left and right singular vectors will be
-///     computed and returned in `u` and `v`, respectively.
-///     If false, `u` and `v` are not set and should never referenced.
-///   - full_matrices: If true, compute full-sized `u` and `v`. If false
-///     (the default), compute only the leading `P` singular vectors.
-///     Ignored if `compute_uv` is `False`.
-///
-/// - Outputs:
-///   - s: Singular values. Shape is `[..., P]`.
-///   - u: Left singular vectors. If `full_matrices` is `False` then shape is
-///     `[..., M, P]`; if `full_matrices` is `True` then shape is
-///     `[..., M, M]`. Undefined if `compute_uv` is `False`.
-///   - v: Left singular vectors. If `full_matrices` is `False` then shape is
-///     `[..., N, P]`. If `full_matrices` is `True` then shape is `[..., N, N]`.
-///     Undefined if `compute_uv` is false.
-@inlinable
-public static func svd<T: FloatingPoint & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  computeUv: Bool = true,
-  fullMatrices: Bool = false
-) -> (s: Tensor<T>, u: Tensor<T>, v: Tensor<T>) {
-  let op = TFE_Op("Svd")
-  op.setAttr("compute_uv", computeUv)
-  op.setAttr("full_matrices", fullMatrices)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Forwards `data` to the output port determined by `pred`.
-///
-/// If `pred` is true, the `data` input is forwarded to `output_true`. Otherwise,
-/// the data goes to `output_false`.
-///
-/// See also `RefSwitch` and `Merge`.
-///
-/// - Parameters:
-///   - data: The tensor to be forwarded to the appropriate output.
-///   - pred: A scalar that specifies which output port will receive data.
-///
-/// - Outputs:
-///   - output_false: If `pred` is false, data will be forwarded to this output.
-///   - output_true: If `pred` is true, data will be forwarded to this output.
-@inlinable
-public static func switch_<T: TensorFlowScalar>(
-  data: Tensor<T>,
-  pred: Tensor<Bool>
-) -> (outputFalse: Tensor<T>, outputTrue: Tensor<T>) {
-  let op = TFE_Op("Switch")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(pred)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Computes the gradient function for function f via backpropagation.
-///
-/// - Parameter input: a list of input tensors of size N + M;
-///
-/// - Attrs:
-///   - Tin: the type list for the input list.
-///   - Tout: the type list for the input list.
-///   - f: The function we want to compute the gradient for.
-///
-///     The function 'f' must be a numerical function which takes N inputs and
-///     produces M outputs. Its gradient function 'g', which is computed by
-///     this SymbolicGradient op is a function taking N + M inputs and
-///     produces N outputs.
-///
-///     I.e. if we have
-///        (y1, y2, ..., y_M) = f(x1, x2, ..., x_N),
-///     then, g is
-///        (dL/dx1, dL/dx2, ..., dL/dx_N) = g(x1, x2, ..., x_N,
-///                                          dL/dy1, dL/dy2, ..., dL/dy_M),
-///
-///     where L is a scalar-value function of (x1, x2, ..., xN) (e.g., the
-///     loss function). dL/dx_i is the partial derivative of L with respect
-///     to x_i.
-///
-///     (Needs some math expert to say the comment above better.)
-///
-/// - Output output: a list of output tensors of size N;
-@inlinable
-public static func symbolicGradient<
-    Tin: TensorArrayProtocol,
-    Tout: TensorGroup,
-    FIn: TensorGroup,
-    FOut: TensorGroup
->(
-  _ input: Tin,
-  f: (FIn) -> FOut
-) -> Tout {
-  let op = TFE_Op("SymbolicGradient")
-  op.setAttr("Tin", input._typeList)
-  op.setAttr("Tout", Tout._typeList)
-  op.setAttr("f", f)
-  let _ = op.addInputList(input)
-  return op.execute(Int(Tout._typeList.count))
-}
-
-/// Creates a dataset that emits the records from one or more TFRecord files.
-///
-/// - Parameters:
-///   - filenames: A scalar or vector containing the name(s) of the file(s) to be
-///     read.
-///   - compression_type: A scalar containing either (i) the empty string (no
-///     compression), (ii) "ZLIB", or (iii) "GZIP".
-///   - buffer_size: A scalar representing the number of bytes to buffer. A value of
-///     0 means no buffering will be performed.
-@inlinable
-public static func tFRecordDataset(
-  filenames: StringTensor,
-  compressionType: StringTensor,
-  bufferSize: Tensor<Int64>
-) -> VariantHandle {
-  let op = TFE_Op("TFRecordDataset")
-  let _ = op.addInput(filenames)
-  let _ = op.addInput(compressionType)
-  let _ = op.addInput(bufferSize)
-  return op.execute(Int(1))
-}
-
-/// A Reader that outputs the records from a TensorFlow Records file.
-///
-/// - Attrs:
-///   - container: If non-empty, this reader is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this reader is named in the given bucket
-///     with this shared_name. Otherwise, the node name is used instead.
-///
-/// - Output reader_handle: The handle to reference the Reader.
-@inlinable
-public static func tFRecordReaderV2(
-  container: String,
-  sharedName: String,
-  compressionType: String
-) -> ResourceHandle {
-  let op = TFE_Op("TFRecordReaderV2")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("compression_type", compressionType)
-  return op.execute(Int(1))
-}
-
-/// CompilationResultProto indicating the status of the TPU compilation.
-@inlinable
-public static func tPUCompilationResult(
-) -> StringTensor {
-  let op = TFE_Op("TPUCompilationResult")
-  
-  return op.execute(Int(1))
-}
-
-/// An op enabling differentiation of TPU Embeddings.
-///
-/// This op simply returns its first input, which is assumed to have been sliced
-/// from the Tensors returned by TPUEmbeddingDequeueActivations. The presence of
-/// this op, and its first argument being a trainable Variable, enables automatic
-/// differentiation of graphs containing embeddings via the TPU Embedding Python
-/// libraries.
-///
-/// - Parameters:
-///   - embedding_variable: A trainable variable, enabling optimizers to find this op.
-///   - sliced_activations: The embedding activations Tensor to return.
-///
-/// - Attrs:
-///   - table_id: The id of the table in the embedding layer configuration from which
-///     these activations were computed.
-///   - lookup_id: Identifier of the set of embedding indices which produced these
-///     activations.
-@inlinable
-public static func tPUEmbeddingActivations(
-  embeddingVariable: Tensor<Float>,
-  slicedActivations: Tensor<Float>,
-  tableId: Int64,
-  lookupId: Int64
-) -> Tensor<Float> {
-  let op = TFE_Op("TPUEmbeddingActivations")
-  op.setAttr("table_id", tableId)
-  op.setAttr("lookup_id", lookupId)
-  let _ = op.addInput(embeddingVariable)
-  let _ = op.addInput(slicedActivations)
-  return op.execute(Int(1))
-}
-
-/// A TPU core selector Op.
-///
-/// This Op produces a set of TPU cores (for warm-up) or a single TPU core
-/// (for regular inference) to execute the TPU program on. The output is
-/// consumed by TPUPartitionedCall.
-///
-/// - Output device_ordinals: A vector 1 or more TPU cores.
-@inlinable
-public static func tPUOrdinalSelector(
-) -> Tensor<Int32> {
-  let op = TFE_Op("TPUOrdinalSelector")
-  
-  return op.execute(Int(1))
-}
-
-/// Calls a function placed on a specified TPU device.
-///
-/// - Parameters:
-///   - args: The arguments to the function.
-///   - device_ordinal: The TPU device ordinal to run the function on.
-///
-/// - Attrs:
-///   - Tin: The types of the arguments to the function.
-///   - Tout: The types of the outputs of the function.
-///   - f: The function to call.
-///
-/// - Output output: The output of the function call.
-@inlinable
-public static func tPUPartitionedCall<
-    Tin: TensorArrayProtocol,
-    Tout: TensorGroup,
-    FIn: TensorGroup,
-    FOut: TensorGroup
->(
-  args: Tin,
-  deviceOrdinal: Tensor<Int32>,
-  f: (FIn) -> FOut
-) -> Tout {
-  let op = TFE_Op("TPUPartitionedCall")
-  op.setAttr("Tin", args._typeList)
-  op.setAttr("Tout", Tout._typeList)
-  op.setAttr("f", f)
-  let _ = op.addInputList(args)
-  let _ = op.addInput(deviceOrdinal)
-  return op.execute(Int(Tout._typeList.count))
-}
-
-/// Runs replicated computations on a distributed TPU system.
-///
-/// - Parameters:
-///   - inputs: the inputs to 'computation', flattened, in replica-major order.
-///   - broadcast_inputs: additional arguments to broadcast to all replicas. The
-///     broadcast inputs are appended to the per-replica inputs when calling
-///     computation.
-///   - guaranteed_constants: arguments which have been guaranteed to not
-///     change their values during the session lifetime. These contain tensors marked as
-///     constant using the GuaranteeConstOp.
-///
-/// - Attrs:
-///   - computation: a function containing the computation to run.
-///   - num_replicas: the number of replicas of the computation to run.
-///   - num_cores_per_replica: the number of logical cores in each replica.
-///   - topology: A serialized tensorflow.tpu.TopologyProto that describes the TPU
-///     topology.
-///   - use_tpu: a bool indicating if this computation will run on TPU or CPU/GPU.
-///     Currently, only supports a default placement (computation is placed on GPU
-///     if one is available, and on CPU if not).
-///   - device_assignment: a flattened array with shape
-///     [replica, num_cores_per_replica, mesh_dimension] that maps the coordinates
-///     of logical cores in each replica of a computation to physical coordinates in
-///     the TPU topology.
-///   - Tinputs: the types of the arguments to 'computation'.
-///   - Tbroadcast_inputs: the types of the additional arguments to broadcast to all
-///     replicas.
-///   - Tguaranteed_constants: the types of the arguments to 'guaranteed_constants'.
-///   - output_types: the types of the outputs of 'computation'.
-///
-/// - Output outputs: the outputs of 'computation'.
-@inlinable
-public static func tPUReplicate<
-    ComputationIn: TensorGroup,
-    ComputationOut: TensorGroup,
-    Tinputs: TensorArrayProtocol,
-    TbroadcastInputs: TensorArrayProtocol,
-    TguaranteedConstants: TensorArrayProtocol,
-    OutputTypes: TensorGroup
->(
-  inputs: Tinputs,
-  broadcastInputs: TbroadcastInputs,
-  variables: [ResourceHandle],
-  guaranteedConstants: TguaranteedConstants,
-  computation: (ComputationIn) -> ComputationOut,
-  numReplicas: Int64,
-  numCoresPerReplica: Int64 = 1,
-  topology: String,
-  useTpu: Bool = true,
-  deviceAssignment: [Int32],
-  hostComputeCore: [String],
-  paddingMap: [String],
-  stepMarkerLocation: String = "STEP_MARK_AT_ENTRY"
-) -> OutputTypes {
-  let op = TFE_Op("TPUReplicate")
-  op.setAttr("computation", computation)
-  op.setAttr("num_replicas", numReplicas)
-  op.setAttr("num_cores_per_replica", numCoresPerReplica)
-  op.setAttr("topology", topology)
-  op.setAttr("use_tpu", useTpu)
-  op.setAttr("device_assignment", deviceAssignment)
-  op.setAttr("host_compute_core", hostComputeCore)
-  op.setAttr("Tinputs", inputs._typeList)
-  op.setAttr("Tbroadcast_inputs", broadcastInputs._typeList)
-  op.setAttr("NumVariables", variables.count)
-  op.setAttr("Tguaranteed_constants", guaranteedConstants._typeList)
-  op.setAttr("output_types", OutputTypes._typeList)
-  op.setAttr("padding_map", paddingMap)
-  op.setAttr("step_marker_location", stepMarkerLocation)
-  let _ = op.addInputList(inputs)
-  let _ = op.addInputList(broadcastInputs)
-  let _ = op.addInputList(variables)
-  let _ = op.addInputList(guaranteedConstants)
-  return op.execute(Int(OutputTypes._typeList.count))
-}
-
-/// Metadata indicaitng how the TPU computation should be replicated.
-///
-/// - Attrs:
-///   - num_replicas: Number of replicas of the computation
-///   - num_cores_per_replica: Number of cores per replica. Used for model parallelism.
-///   - topology: TopologyProto indicating the topology of the TPU pod slice.
-///   - use_tpu: Whether to place the computation on the TPU.
-///   - device_assignment: The assignment of devices for the computation.
-///   - computation_shape: DEPRECATED. Use num_cores_per_replica instead.
-@inlinable
-public static func tPUReplicateMetadata(
-  numReplicas: Int64,
-  numCoresPerReplica: Int64 = 1,
-  topology: String,
-  useTpu: Bool = true,
-  deviceAssignment: [Int32],
-  computationShape: [Int32],
-  hostComputeCore: [String],
-  paddingMap: [String],
-  stepMarkerLocation: String = "STEP_MARK_AT_ENTRY"
-) {
-  let op = TFE_Op("TPUReplicateMetadata")
-  op.setAttr("num_replicas", numReplicas)
-  op.setAttr("num_cores_per_replica", numCoresPerReplica)
-  op.setAttr("topology", topology)
-  op.setAttr("use_tpu", useTpu)
-  op.setAttr("device_assignment", deviceAssignment)
-  op.setAttr("computation_shape", computationShape)
-  op.setAttr("host_compute_core", hostComputeCore)
-  op.setAttr("padding_map", paddingMap)
-  op.setAttr("step_marker_location", stepMarkerLocation)
-  op.execute()
-}
-
-/// Connects N inputs to an N-way replicated TPU computation.
-@inlinable
-public static func tPUReplicatedInput<T: TensorFlowScalar>(
-  inputs: [Tensor<T>]
-) -> Tensor<T> {
-  let op = TFE_Op("TPUReplicatedInput")
-  op.setAttr("N", inputs.count)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInputList(inputs)
-  return op.execute(Int(1))
-}
-
-/// Connects outputs of an N-way replicated computation to N outputs.
-@inlinable
-public static func tPUReplicatedOutput<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  numReplicas: Int64
-) -> [Tensor<T>] {
-  let op = TFE_Op("TPUReplicatedOutput")
-  op.setAttr("num_replicas", numReplicas)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(numReplicas))
-}
-
-/// Creates a dataset that contains `count` elements from the `input_dataset`.
-///
-/// - Parameter count: A scalar representing the number of elements from the `input_dataset`
-///   that should be taken. A value of `-1` indicates that all of `input_dataset`
-///   is taken.
-@inlinable
-public static func takeDataset(
-  inputDataset: VariantHandle,
-  count: Tensor<Int64>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("TakeDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(count)
-  return op.execute(Int(1))
-}
-
-/// Read `SparseTensors` from a `SparseTensorsMap` and concatenate them.
-///
-/// The input `sparse_handles` must be an `int64` matrix of shape `[N, 1]` where
-/// `N` is the minibatch size and the rows correspond to the output handles of
-/// `AddSparseToTensorsMap` or `AddManySparseToTensorsMap`.  The ranks of the
-/// original `SparseTensor` objects that went into the given input ops must all
-/// match.  When the final `SparseTensor` is created, it has rank one
-/// higher than the ranks of the incoming `SparseTensor` objects
-/// (they have been concatenated along a new row dimension on the left).
-///
-/// The output `SparseTensor` object's shape values for all dimensions but the
-/// first are the max across the input `SparseTensor` objects' shape values
-/// for the corresponding dimensions.  Its first shape value is `N`, the minibatch
-/// size.
-///
-/// The input `SparseTensor` objects' indices are assumed ordered in
-/// standard lexicographic order.  If this is not the case, after this
-/// step run `SparseReorder` to restore index ordering.
-///
-/// For example, if the handles represent an input, which is a `[2, 3]` matrix
-/// representing two original `SparseTensor` objects:
-///
-/// ```
-///     index = [ 0]
-///             [10]
-///             [20]
-///     values = [1, 2, 3]
-///     shape = [50]
-/// ```
-///
-/// and
-///
-/// ```
-///     index = [ 2]
-///             [10]
-///     values = [4, 5]
-///     shape = [30]
-/// ```
-///
-/// then the final `SparseTensor` will be:
-///
-/// ```
-///     index = [0  0]
-///             [0 10]
-///             [0 20]
-///             [1  2]
-///             [1 10]
-///     values = [1, 2, 3, 4, 5]
-///     shape = [2 50]
-/// ```
-///
-/// - Parameter sparse_handles: 1-D, The `N` serialized `SparseTensor` objects.
-///   Shape: `[N]`.
-///
-/// - Attrs:
-///   - dtype: The `dtype` of the `SparseTensor` objects stored in the
-///     `SparseTensorsMap`.
-///   - container: The container name for the `SparseTensorsMap` read by this op.
-///   - shared_name: The shared name for the `SparseTensorsMap` read by this op.
-///     It should not be blank; rather the `shared_name` or unique Operation name
-///     of the Op that created the original `SparseTensorsMap` should be used.
-///
-/// - Outputs:
-///   - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
-///   - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
-///   - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
-@inlinable
-public static func takeManySparseFromTensorsMap<Dtype: TensorFlowScalar>(
-  sparseHandles: Tensor<Int64>,
-  container: String,
-  sharedName: String
-) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
-  let op = TFE_Op("TakeManySparseFromTensorsMap")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  let _ = op.addInput(sparseHandles)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Computes tan of x element-wise.
-@inlinable
-public static func tan<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Tan")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes hyperbolic tangent of `x` element-wise.
-@inlinable
-public static func tanh<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Tanh")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Computes the gradient for the tanh of `x` wrt its input.
-///
-/// Specifically, `grad = dy * (1 - y*y)`, where `y = tanh(x)`, and `dy`
-/// is the corresponding input gradient.
-@inlinable
-public static func tanhGrad<T: FloatingPoint & TensorFlowScalar>(
-  _ y: Tensor<T>,
-  dy: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("TanhGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(y)
-  let _ = op.addInput(dy)
-  return op.execute(Int(1))
-}
-
-/// Deprecated. Use TensorArrayCloseV3
-@inlinable
-public static func tensorArrayCloseV2(
-  handle: StringTensor
-) {
-  let op = TFE_Op("TensorArrayCloseV2")
-  let _ = op.addInput(handle)
-  op.execute()
-}
-
-/// Delete the TensorArray from its resource container.
-///
-/// This enables the user to close and release the resource in the middle
-/// of a step/run.
-///
-/// - Parameter handle: The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
-@inlinable
-public static func tensorArrayCloseV3(
-  handle: ResourceHandle
-) {
-  let op = TFE_Op("TensorArrayCloseV3")
-  let _ = op.addInput(handle)
-  op.execute()
-}
-
-/// Deprecated. Use TensorArrayConcatV3
-@inlinable
-public static func tensorArrayConcatV2<Dtype: TensorFlowScalar>(
-  handle: StringTensor,
-  flowIn: Tensor<Float>,
-  elementShapeExcept0: TensorShape?
-) -> (value: Tensor<Dtype>, lengths: Tensor<Int64>) {
-  let op = TFE_Op("TensorArrayConcatV2")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("element_shape_except0", elementShapeExcept0)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Concat the elements from the TensorArray into value `value`.
-///
-/// Takes `T` elements of shapes
-///
-///   ```
-///   (n0 x d0 x d1 x ...), (n1 x d0 x d1 x ...), ..., (n(T-1) x d0 x d1 x ...)
-///   ```
-///
-/// and concatenates them into a Tensor of shape:
-///
-///   ```(n0 + n1 + ... + n(T-1) x d0 x d1 x ...)```
-///
-/// All elements must have the same shape (excepting the first dimension).
-///
-/// - Parameters:
-///   - handle: The handle to a TensorArray.
-///   - flow_in: A float scalar that enforces proper chaining of operations.
-///
-/// - Attrs:
-///   - dtype: The type of the elem that is returned.
-///   - element_shape_except0: The expected shape of an element, if known,
-///     excluding the first dimension. Used to validate the shapes of
-///     TensorArray elements. If this shape is not fully specified, concatenating
-///     zero-size TensorArrays is an error.
-///
-/// - Outputs:
-///   - value: All of the elements in the TensorArray, concatenated along the first
-///     axis.
-///   - lengths: A vector of the row sizes of the original T elements in the
-///     value output.  In the example above, this would be the values:
-///     `(n1, n2, ..., n(T-1))`.
-@inlinable
-public static func tensorArrayConcatV3<Dtype: TensorFlowScalar>(
-  handle: ResourceHandle,
-  flowIn: Tensor<Float>,
-  elementShapeExcept0: TensorShape?
-) -> (value: Tensor<Dtype>, lengths: Tensor<Int64>) {
-  let op = TFE_Op("TensorArrayConcatV3")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("element_shape_except0", elementShapeExcept0)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Deprecated. Use TensorArrayGatherV3
-@inlinable
-public static func tensorArrayGatherV2<Dtype: TensorFlowScalar>(
-  handle: StringTensor,
-  indices: Tensor<Int32>,
-  flowIn: Tensor<Float>,
-  elementShape: TensorShape?
-) -> Tensor<Dtype> {
-  let op = TFE_Op("TensorArrayGatherV2")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("element_shape", elementShape)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Gather specific elements from the TensorArray into output `value`.
-///
-/// All elements selected by `indices` must have the same shape.
-///
-/// - Parameters:
-///   - handle: The handle to a TensorArray.
-///   - indices: The locations in the TensorArray from which to read tensor elements.
-///   - flow_in: A float scalar that enforces proper chaining of operations.
-///
-/// - Attrs:
-///   - dtype: The type of the elem that is returned.
-///   - element_shape: The expected shape of an element, if known. Used to
-///     validate the shapes of TensorArray elements. If this shape is not
-///     fully specified, gathering zero-size TensorArrays is an error.
-///
-/// - Output value: All of the elements in the TensorArray, concatenated along a new
-///   axis (the new dimension 0).
-@inlinable
-public static func tensorArrayGatherV3<Dtype: TensorFlowScalar>(
-  handle: ResourceHandle,
-  indices: Tensor<Int32>,
-  flowIn: Tensor<Float>,
-  elementShape: TensorShape?
-) -> Tensor<Dtype> {
-  let op = TFE_Op("TensorArrayGatherV3")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("element_shape", elementShape)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Deprecated. Use TensorArrayGradV3
-@inlinable
-public static func tensorArrayGradV2(
-  handle: StringTensor,
-  flowIn: Tensor<Float>,
-  source: String
-) -> StringTensor {
-  let op = TFE_Op("TensorArrayGradV2")
-  op.setAttr("source", source)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Creates a TensorArray for storing the gradients of values in the given handle.
-///
-/// If the given TensorArray gradient already exists, returns a reference to it.
-///
-/// Locks the size of the original TensorArray by disabling its dynamic size flag.
-///
-/// **A note about the input flow_in:**
-///
-/// The handle flow_in forces the execution of the gradient lookup to occur
-/// only after certain other operations have occurred.  For example, when
-/// the forward TensorArray is dynamically sized, writes to this TensorArray
-/// may resize the object.  The gradient TensorArray is statically sized based
-/// on the size of the forward TensorArray when this operation executes.
-/// Furthermore, the size of the forward TensorArray is frozen by this call.
-/// As a result, the flow is used to ensure that the call to generate the gradient
-/// TensorArray only happens after all writes are executed.
-///
-/// In the case of dynamically sized TensorArrays, gradient computation should
-/// only be performed on read operations that have themselves been chained via
-/// flow to occur only after all writes have executed. That way the final size
-/// of the forward TensorArray is known when this operation is called.
-///
-/// **A note about the source attribute:**
-///
-/// TensorArray gradient calls use an accumulator TensorArray object.  If
-/// multiple gradients are calculated and run in the same session, the multiple
-/// gradient nodes may accidentally flow through the same accumulator TensorArray.
-/// This double counts and generally breaks the TensorArray gradient flow.
-///
-/// The solution is to identify which gradient call this particular
-/// TensorArray gradient is being called in.  This is performed by identifying
-/// a unique string (e.g. "gradients", "gradients_1", ...) from the input
-/// gradient Tensor's name.  This string is used as a suffix when creating
-/// the TensorArray gradient object here (the attribute `source`).
-///
-/// The attribute `source` is added as a suffix to the forward TensorArray's
-/// name when performing the creation / lookup, so that each separate gradient
-/// calculation gets its own TensorArray accumulator.
-///
-/// - Parameters:
-///   - handle: The handle to the forward TensorArray.
-///   - flow_in: A float scalar that enforces proper chaining of operations.
-///
-/// - Attr source: The gradient source string, used to decide which gradient TensorArray
-///   to return.
-@inlinable
-public static func tensorArrayGradV3(
-  handle: ResourceHandle,
-  flowIn: Tensor<Float>,
-  source: String
-) -> (gradHandle: ResourceHandle, flowOut: Tensor<Float>) {
-  let op = TFE_Op("TensorArrayGradV3")
-  op.setAttr("source", source)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Creates a TensorArray for storing multiple gradients of values in the given handle.
-///
-/// Similar to TensorArrayGradV3. However it creates an accumulator with an
-/// expanded shape compared to the input TensorArray whose gradient is being
-/// computed. This enables multiple gradients for the same TensorArray to be
-/// calculated using the same accumulator.
-///
-/// - Parameters:
-///   - handle: The handle to the forward TensorArray.
-///   - flow_in: A float scalar that enforces proper chaining of operations.
-///   - shape_to_prepend: An int32 vector representing a shape. Elements in the gradient accumulator will
-///     have shape which is this shape_to_prepend value concatenated with shape of the
-///     elements in the TensorArray corresponding to the input handle.
-///
-/// - Attr source: The gradient source string, used to decide which gradient TensorArray
-///   to return.
-@inlinable
-public static func tensorArrayGradWithShape(
-  handle: ResourceHandle,
-  flowIn: Tensor<Float>,
-  shapeToPrepend: Tensor<Int32>,
-  source: String
-) -> (gradHandle: ResourceHandle, flowOut: Tensor<Float>) {
-  let op = TFE_Op("TensorArrayGradWithShape")
-  op.setAttr("source", source)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(flowIn)
-  let _ = op.addInput(shapeToPrepend)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Deprecated. Use TensorArrayReadV3
-@inlinable
-public static func tensorArrayReadV2<Dtype: TensorFlowScalar>(
-  handle: StringTensor,
-  index: Tensor<Int32>,
-  flowIn: Tensor<Float>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("TensorArrayReadV2")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(index)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Read an element from the TensorArray into output `value`.
-///
-/// - Parameters:
-///   - handle: The handle to a TensorArray.
-///   - flow_in: A float scalar that enforces proper chaining of operations.
-///
-/// - Attr dtype: The type of the elem that is returned.
-///
-/// - Output value: The tensor that is read from the TensorArray.
-@inlinable
-public static func tensorArrayReadV3<Dtype: TensorFlowScalar>(
-  handle: ResourceHandle,
-  index: Tensor<Int32>,
-  flowIn: Tensor<Float>
-) -> Tensor<Dtype> {
-  let op = TFE_Op("TensorArrayReadV3")
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(index)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Deprecated. Use TensorArrayScatterV3
-@inlinable
-public static func tensorArrayScatterV2<T: TensorFlowScalar>(
-  handle: StringTensor,
-  indices: Tensor<Int32>,
-  value: Tensor<T>,
-  flowIn: Tensor<Float>
-) -> Tensor<Float> {
-  let op = TFE_Op("TensorArrayScatterV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(value)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Scatter the data from the input value into specific TensorArray elements.
-///
-/// `indices` must be a vector, its length must match the first dim of `value`.
-///
-/// - Parameters:
-///   - handle: The handle to a TensorArray.
-///   - indices: The locations at which to write the tensor elements.
-///   - value: The concatenated tensor to write to the TensorArray.
-///   - flow_in: A float scalar that enforces proper chaining of operations.
-///
-/// - Output flow_out: A float scalar that enforces proper chaining of operations.
-@inlinable
-public static func tensorArrayScatterV3<T: TensorFlowScalar>(
-  handle: ResourceHandle,
-  indices: Tensor<Int32>,
-  value: Tensor<T>,
-  flowIn: Tensor<Float>
-) -> Tensor<Float> {
-  let op = TFE_Op("TensorArrayScatterV3")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(value)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Deprecated. Use TensorArraySizeV3
-@inlinable
-public static func tensorArraySizeV2(
-  handle: StringTensor,
-  flowIn: Tensor<Float>
-) -> Tensor<Int32> {
-  let op = TFE_Op("TensorArraySizeV2")
-  let _ = op.addInput(handle)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Get the current size of the TensorArray.
-///
-/// - Parameters:
-///   - handle: The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
-///   - flow_in: A float scalar that enforces proper chaining of operations.
-///
-/// - Output size: The current size of the TensorArray.
-@inlinable
-public static func tensorArraySizeV3(
-  handle: ResourceHandle,
-  flowIn: Tensor<Float>
-) -> Tensor<Int32> {
-  let op = TFE_Op("TensorArraySizeV3")
-  let _ = op.addInput(handle)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Deprecated. Use TensorArraySplitV3
-@inlinable
-public static func tensorArraySplitV2<T: TensorFlowScalar>(
-  handle: StringTensor,
-  value: Tensor<T>,
-  lengths: Tensor<Int64>,
-  flowIn: Tensor<Float>
-) -> Tensor<Float> {
-  let op = TFE_Op("TensorArraySplitV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(value)
-  let _ = op.addInput(lengths)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Split the data from the input value into TensorArray elements.
-///
-/// Assuming that `lengths` takes on values
-///
-///   ```(n0, n1, ..., n(T-1))```
-///
-/// and that `value` has shape
-///
-///   ```(n0 + n1 + ... + n(T-1) x d0 x d1 x ...)```,
-///
-/// this splits values into a TensorArray with T tensors.
-///
-/// TensorArray index t will be the subtensor of values with starting position
-///
-///   ```(n0 + n1 + ... + n(t-1), 0, 0, ...)```
-///
-/// and having size
-///
-///   ```nt x d0 x d1 x ...```
-///
-/// - Parameters:
-///   - handle: The handle to a TensorArray.
-///   - value: The concatenated tensor to write to the TensorArray.
-///   - lengths: The vector of lengths, how to split the rows of value into the
-///     TensorArray.
-///   - flow_in: A float scalar that enforces proper chaining of operations.
-///
-/// - Output flow_out: A float scalar that enforces proper chaining of operations.
-@inlinable
-public static func tensorArraySplitV3<T: TensorFlowScalar>(
-  handle: ResourceHandle,
-  value: Tensor<T>,
-  lengths: Tensor<Int64>,
-  flowIn: Tensor<Float>
-) -> Tensor<Float> {
-  let op = TFE_Op("TensorArraySplitV3")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(value)
-  let _ = op.addInput(lengths)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Deprecated. Use TensorArrayV3
-@inlinable
-public static func tensorArrayV2(
-  size: Tensor<Int32>,
-  dtype: TensorDataType,
-  elementShape: TensorShape?,
-  dynamicSize: Bool = false,
-  clearAfterRead: Bool = true,
-  tensorArrayName: String
-) -> StringTensor {
-  let op = TFE_Op("TensorArrayV2")
-  op.setAttr("dtype", dtype)
-  op.setAttr("element_shape", elementShape)
-  op.setAttr("dynamic_size", dynamicSize)
-  op.setAttr("clear_after_read", clearAfterRead)
-  op.setAttr("tensor_array_name", tensorArrayName)
-  let _ = op.addInput(size)
-  return op.execute(Int(1))
-}
-
-/// An array of Tensors of given size.
-///
-/// Write data via Write and read via Read or Pack.
-///
-/// - Parameter size: The size of the array.
-///
-/// - Attrs:
-///   - dtype: The type of the elements on the tensor_array.
-///   - element_shape: The expected shape of an element, if known. Used to
-///     validate the shapes of TensorArray elements. If this shape is not
-///     fully specified, gathering zero-size TensorArrays is an error.
-///   - dynamic_size: A boolean that determines whether writes to the TensorArray
-///     are allowed to grow the size.  By default, this is not allowed.
-///   - clear_after_read: If true (default), Tensors in the TensorArray are cleared
-///     after being read.  This disables multiple read semantics but allows early
-///     release of memory.
-///   - identical_element_shapes: If true (default is false), then all
-///     elements in the TensorArray will be expected to have have identical shapes.
-///     This allows certain behaviors, like dynamically checking for
-///     consistent shapes on write, and being able to fill in properly
-///     shaped zero tensors on stack -- even if the element_shape attribute
-///     is not fully defined.
-///   - tensor_array_name: Overrides the name used for the temporary tensor_array
-///     resource. Default value is the name of the 'TensorArray' op (which
-///     is guaranteed unique).
-///
-/// - Outputs:
-///   - handle: The handle to the TensorArray.
-///   - flow: A scalar used to control gradient flow.
-@inlinable
-public static func tensorArrayV3(
-  size: Tensor<Int32>,
-  dtype: TensorDataType,
-  elementShape: TensorShape?,
-  dynamicSize: Bool = false,
-  clearAfterRead: Bool = true,
-  identicalElementShapes: Bool = false,
-  tensorArrayName: String
-) -> (handle: ResourceHandle, flow: Tensor<Float>) {
-  let op = TFE_Op("TensorArrayV3")
-  op.setAttr("dtype", dtype)
-  op.setAttr("element_shape", elementShape)
-  op.setAttr("dynamic_size", dynamicSize)
-  op.setAttr("clear_after_read", clearAfterRead)
-  op.setAttr("identical_element_shapes", identicalElementShapes)
-  op.setAttr("tensor_array_name", tensorArrayName)
-  let _ = op.addInput(size)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Deprecated. Use TensorArrayGradV3
-@inlinable
-public static func tensorArrayWriteV2<T: TensorFlowScalar>(
-  handle: StringTensor,
-  index: Tensor<Int32>,
-  value: Tensor<T>,
-  flowIn: Tensor<Float>
-) -> Tensor<Float> {
-  let op = TFE_Op("TensorArrayWriteV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(index)
-  let _ = op.addInput(value)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Push an element onto the tensor_array.
-///
-/// - Parameters:
-///   - handle: The handle to a TensorArray.
-///   - index: The position to write to inside the TensorArray.
-///   - value: The tensor to write to the TensorArray.
-///   - flow_in: A float scalar that enforces proper chaining of operations.
-///
-/// - Output flow_out: A float scalar that enforces proper chaining of operations.
-@inlinable
-public static func tensorArrayWriteV3<T: TensorFlowScalar>(
-  handle: ResourceHandle,
-  index: Tensor<Int32>,
-  value: Tensor<T>,
-  flowIn: Tensor<Float>
-) -> Tensor<Float> {
-  let op = TFE_Op("TensorArrayWriteV3")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(handle)
-  let _ = op.addInput(index)
-  let _ = op.addInput(value)
-  let _ = op.addInput(flowIn)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that emits `components` as a tuple of tensors once.
-@inlinable
-public static func tensorDataset<ToutputTypes: TensorArrayProtocol>(
-  components: ToutputTypes,
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("TensorDataset")
-  op.setAttr("Toutput_types", components._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInputList(components)
-  return op.execute(Int(1))
-}
-
-/// Creates a tree resource and returns a handle to it.
-///
-/// - Parameters:
-///   - tree_handle: Handle to the tree resource to be created.
-///   - tree_config: Serialized proto string of the boosted_trees.Tree.
-@inlinable
-public static func tensorForestCreateTreeVariable(
-  treeHandle: ResourceHandle,
-  treeConfig: StringTensor
-) {
-  let op = TFE_Op("TensorForestCreateTreeVariable")
-  let _ = op.addInput(treeHandle)
-  let _ = op.addInput(treeConfig)
-  op.execute()
-}
-
-/// Deserializes a proto into the tree handle
-///
-/// - Parameters:
-///   - tree_handle: Handle to the tree resource to be restored.
-///   - tree_config: Serialied proto string of the boosted_trees.Tree proto.
-@inlinable
-public static func tensorForestTreeDeserialize(
-  treeHandle: ResourceHandle,
-  treeConfig: StringTensor
-) {
-  let op = TFE_Op("TensorForestTreeDeserialize")
-  let _ = op.addInput(treeHandle)
-  let _ = op.addInput(treeConfig)
-  op.execute()
-}
-
-/// Checks whether a tree has been initialized.
-///
-/// - Parameter tree_handle: Handle to the tree.
-///
-/// - Output is_initialized: Whether the tree is initialized.
-@inlinable
-public static func tensorForestTreeIsInitializedOp(
-  treeHandle: ResourceHandle
-) -> Tensor<Bool> {
-  let op = TFE_Op("TensorForestTreeIsInitializedOp")
-  let _ = op.addInput(treeHandle)
-  return op.execute(Int(1))
-}
-
-/// Output the logits for the given input data
-///
-/// - Parameters:
-///   - tree_handle: Handle to the tree resource.
-///   - dense_features: Rank 2 dense features tensor.
-///
-/// - Attr logits_dimension: Scalar, dimension of the logits.
-///
-/// - Output logits: The logits predictions from the tree for each instance in the batch.
-@inlinable
-public static func tensorForestTreePredict(
-  treeHandle: ResourceHandle,
-  denseFeatures: Tensor<Float>,
-  logitsDimension: Int64
-) -> Tensor<Float> {
-  let op = TFE_Op("TensorForestTreePredict")
-  op.setAttr("logits_dimension", logitsDimension)
-  let _ = op.addInput(treeHandle)
-  let _ = op.addInput(denseFeatures)
-  return op.execute(Int(1))
-}
-
-/// Creates a handle to a TensorForestTreeResource
-@inlinable
-public static func tensorForestTreeResourceHandleOp(
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("TensorForestTreeResourceHandleOp")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Serializes the tree handle to a proto
-///
-/// - Parameter tree_handle: Handle to the tree resource to be serialized.
-///
-/// - Output tree_config: Serialied proto string of the tree resource.
-@inlinable
-public static func tensorForestTreeSerialize(
-  treeHandle: ResourceHandle
-) -> StringTensor {
-  let op = TFE_Op("TensorForestTreeSerialize")
-  let _ = op.addInput(treeHandle)
-  return op.execute(Int(1))
-}
-
-/// Get the number of nodes in a tree
-///
-/// - Parameter tree_handle: Handle to the tree resource.
-///
-/// - Output tree_size: The size of the tree.
-@inlinable
-public static func tensorForestTreeSize(
-  treeHandle: ResourceHandle
-) -> Tensor<Int32> {
-  let op = TFE_Op("TensorForestTreeSize")
-  let _ = op.addInput(treeHandle)
-  return op.execute(Int(1))
-}
-
-/// Concats all tensors in the list along the 0th dimension.
-///
-/// Requires that all tensors have the same shape except the first dimension.
-///
-/// input_handle: The input list.
-/// tensor: The concated result.
-/// lengths: Output tensor containing sizes of the 0th dimension of tensors in the list, used for computing the gradient.
-///
-@inlinable
-public static func tensorListConcat<ElementDtype: TensorFlowScalar>(
-  inputHandle: VariantHandle,
-  elementShape: TensorShape?
-) -> (tensor: Tensor<ElementDtype>, lengths: Tensor<Int64>) {
-  let op = TFE_Op("TensorListConcat")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  op.setAttr("element_shape", elementShape)
-  let _ = op.addInput(inputHandle)
-  return op.execute(Int(1), Int(1))
-}
-
-@inlinable
-public static func tensorListConcatLists(
-  inputA: VariantHandle,
-  inputB: VariantHandle,
-  elementDtype: TensorDataType
-) -> VariantHandle {
-  let op = TFE_Op("TensorListConcatLists")
-  op.setAttr("element_dtype", elementDtype)
-  let _ = op.addInput(inputA)
-  let _ = op.addInput(inputB)
-  return op.execute(Int(1))
-}
-
-/// Concats all tensors in the list along the 0th dimension.
-///
-/// Requires that all tensors have the same shape except the first dimension.
-///
-/// input_handle: The input list.
-/// element_shape: The shape of the uninitialized elements in the list. If the first
-///   dimension is not -1, it is assumed that all list elements have the same
-///   leading dim.
-/// leading_dims: The list of leading dims of uninitialized list elements. Used if
-///   the leading dim of input_handle.element_shape or the element_shape input arg
-///   is not already set.
-/// tensor: The concated result.
-/// lengths: Output tensor containing sizes of the 0th dimension of tensors in the list, used for computing the gradient.
-///
-@inlinable
-public static func tensorListConcatV2<
-    ElementDtype: TensorFlowScalar,
-    ShapeType: BinaryInteger & TensorFlowScalar
->(
-  inputHandle: VariantHandle,
-  elementShape: Tensor<ShapeType>,
-  leadingDims: Tensor<Int64>
-) -> (tensor: Tensor<ElementDtype>, lengths: Tensor<Int64>) {
-  let op = TFE_Op("TensorListConcatV2")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
-  let _ = op.addInput(inputHandle)
-  let _ = op.addInput(elementShape)
-  let _ = op.addInput(leadingDims)
-  return op.execute(Int(1), Int(1))
-}
-
-/// The shape of the elements of the given list, as a tensor.
-///
-///   input_handle: the list
-///   element_shape: the shape of elements of the list
-@inlinable
-public static func tensorListElementShape<ShapeType: BinaryInteger & TensorFlowScalar>(
-  inputHandle: VariantHandle
-) -> Tensor<ShapeType> {
-  let op = TFE_Op("TensorListElementShape")
-  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
-  let _ = op.addInput(inputHandle)
-  return op.execute(Int(1))
-}
-
-/// Creates a TensorList which, when stacked, has the value of `tensor`.
-///
-/// Each tensor in the result list corresponds to one row of the input tensor.
-///
-/// tensor: The input tensor.
-/// output_handle: The list.
-@inlinable
-public static func tensorListFromTensor<
-    ElementDtype: TensorFlowScalar,
-    ShapeType: BinaryInteger & TensorFlowScalar
->(
-  _ tensor: Tensor<ElementDtype>,
-  elementShape: Tensor<ShapeType>
-) -> VariantHandle {
-  let op = TFE_Op("TensorListFromTensor")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(elementShape)
-  return op.execute(Int(1))
-}
-
-/// Creates a Tensor by indexing into the TensorList.
-///
-/// Each row in the produced Tensor corresponds to the element in the TensorList
-/// specified by the given index (see `tf.gather`).  
-///
-/// input_handle: The input tensor list.
-/// indices: The indices used to index into the list.
-/// values: The tensor.
-@inlinable
-public static func tensorListGather<ElementDtype: TensorFlowScalar>(
-  inputHandle: VariantHandle,
-  indices: Tensor<Int32>,
-  elementShape: Tensor<Int32>
-) -> Tensor<ElementDtype> {
-  let op = TFE_Op("TensorListGather")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  let _ = op.addInput(inputHandle)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(elementShape)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func tensorListGetItem<ElementDtype: TensorFlowScalar>(
-  inputHandle: VariantHandle,
-  index: Tensor<Int32>,
-  elementShape: Tensor<Int32>
-) -> Tensor<ElementDtype> {
-  let op = TFE_Op("TensorListGetItem")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  let _ = op.addInput(inputHandle)
-  let _ = op.addInput(index)
-  let _ = op.addInput(elementShape)
-  return op.execute(Int(1))
-}
-
-/// Returns the number of tensors in the input tensor list.
-///
-/// input_handle: the input list
-/// length: the number of tensors in the list
-@inlinable
-public static func tensorListLength(
-  inputHandle: VariantHandle
-) -> Tensor<Int32> {
-  let op = TFE_Op("TensorListLength")
-  let _ = op.addInput(inputHandle)
-  return op.execute(Int(1))
-}
-
-/// Returns the last element of the input list as well as a list with all but that element.
-///
-/// Fails if the list is empty.
-///
-/// input_handle: the input list
-/// tensor: the withdrawn last element of the list
-/// element_dtype: the type of elements in the list
-/// element_shape: the shape of the output tensor
-@inlinable
-public static func tensorListPopBack<ElementDtype: TensorFlowScalar>(
-  inputHandle: VariantHandle,
-  elementShape: Tensor<Int32>
-) -> (outputHandle: VariantHandle, tensor: Tensor<ElementDtype>) {
-  let op = TFE_Op("TensorListPopBack")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  let _ = op.addInput(inputHandle)
-  let _ = op.addInput(elementShape)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Returns a list list which has the passed-in `Tensor` as last element and the other elements of the given list in `input_handle`.
-///
-/// tensor: The tensor to put on the list.
-/// input_handle: The old list.
-/// output_handle: A list with the elements of the old list followed by tensor.
-/// element_dtype: the type of elements in the list.
-/// element_shape: a shape compatible with that of elements in the list.
-@inlinable
-public static func tensorListPushBack<ElementDtype: TensorFlowScalar>(
-  inputHandle: VariantHandle,
-  _ tensor: Tensor<ElementDtype>
-) -> VariantHandle {
-  let op = TFE_Op("TensorListPushBack")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  let _ = op.addInput(inputHandle)
-  let _ = op.addInput(tensor)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func tensorListPushBackBatch<ElementDtype: TensorFlowScalar>(
-  inputHandles: VariantHandle,
-  _ tensor: Tensor<ElementDtype>
-) -> VariantHandle {
-  let op = TFE_Op("TensorListPushBackBatch")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  let _ = op.addInput(inputHandles)
-  let _ = op.addInput(tensor)
-  return op.execute(Int(1))
-}
-
-/// List of the given size with empty elements.
-///
-/// element_shape: the shape of the future elements of the list
-/// num_elements: the number of elements to reserve
-/// handle: the output list
-/// element_dtype: the desired type of elements in the list.
-@inlinable
-public static func tensorListReserve<ShapeType: BinaryInteger & TensorFlowScalar>(
-  elementShape: Tensor<ShapeType>,
-  numElements: Tensor<Int32>,
-  elementDtype: TensorDataType
-) -> VariantHandle {
-  let op = TFE_Op("TensorListReserve")
-  op.setAttr("element_dtype", elementDtype)
-  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
-  let _ = op.addInput(elementShape)
-  let _ = op.addInput(numElements)
-  return op.execute(Int(1))
-}
-
-/// Resizes the list.
-///
-///
-/// input_handle: the input list
-/// size: size of the output list
-///
-@inlinable
-public static func tensorListResize(
-  inputHandle: VariantHandle,
-  size: Tensor<Int32>
-) -> VariantHandle {
-  let op = TFE_Op("TensorListResize")
-  let _ = op.addInput(inputHandle)
-  let _ = op.addInput(size)
-  return op.execute(Int(1))
-}
-
-/// Creates a TensorList by indexing into a Tensor.
-///
-/// Each member of the TensorList corresponds to one row of the input tensor,
-/// specified by the given index (see `tf.gather`).
-///
-/// tensor: The input tensor.
-/// indices: The indices used to index into the list.
-/// element_shape: The shape of the elements in the list (can be less specified than
-///   the shape of the tensor).  
-/// output_handle: The TensorList.
-@inlinable
-public static func tensorListScatter<
-    ElementDtype: TensorFlowScalar,
-    ShapeType: BinaryInteger & TensorFlowScalar
->(
-  _ tensor: Tensor<ElementDtype>,
-  indices: Tensor<Int32>,
-  elementShape: Tensor<ShapeType>
-) -> VariantHandle {
-  let op = TFE_Op("TensorListScatter")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(elementShape)
-  return op.execute(Int(1))
-}
-
-/// Scatters tensor at indices in an input list.
-///
-/// Each member of the TensorList corresponds to one row of the input tensor,
-/// specified by the given index (see `tf.gather`).
-///
-/// input_handle: The list to scatter into.
-/// tensor: The input tensor.
-/// indices: The indices used to index into the list.
-/// output_handle: The TensorList.
-@inlinable
-public static func tensorListScatterIntoExistingList<ElementDtype: TensorFlowScalar>(
-  inputHandle: VariantHandle,
-  _ tensor: Tensor<ElementDtype>,
-  indices: Tensor<Int32>
-) -> VariantHandle {
-  let op = TFE_Op("TensorListScatterIntoExistingList")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  let _ = op.addInput(inputHandle)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(indices)
-  return op.execute(Int(1))
-}
-
-/// Creates a TensorList by indexing into a Tensor.
-///
-/// Each member of the TensorList corresponds to one row of the input tensor,
-/// specified by the given index (see `tf.gather`).
-///
-/// tensor: The input tensor.
-/// indices: The indices used to index into the list.
-/// element_shape: The shape of the elements in the list (can be less specified than
-///   the shape of the tensor).
-/// num_elements: The size of the output list. Must be large enough to accommodate
-///   the largest index in indices. If -1, the list is just large enough to include
-///   the largest index in indices.
-/// output_handle: The TensorList.
-@inlinable
-public static func tensorListScatterV2<
-    ElementDtype: TensorFlowScalar,
-    ShapeType: BinaryInteger & TensorFlowScalar
->(
-  _ tensor: Tensor<ElementDtype>,
-  indices: Tensor<Int32>,
-  elementShape: Tensor<ShapeType>,
-  numElements: Tensor<Int32>
-) -> VariantHandle {
-  let op = TFE_Op("TensorListScatterV2")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(elementShape)
-  let _ = op.addInput(numElements)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func tensorListSetItem<ElementDtype: TensorFlowScalar>(
-  inputHandle: VariantHandle,
-  index: Tensor<Int32>,
-  item: Tensor<ElementDtype>
-) -> VariantHandle {
-  let op = TFE_Op("TensorListSetItem")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  let _ = op.addInput(inputHandle)
-  let _ = op.addInput(index)
-  let _ = op.addInput(item)
-  return op.execute(Int(1))
-}
-
-/// Splits a tensor into a list.
-///
-/// list[i] corresponds to lengths[i] tensors from the input tensor.
-/// The tensor must have rank at least 1 and contain exactly sum(lengths) elements.
-///
-/// tensor: The input tensor.
-/// element_shape: A shape compatible with that of elements in the tensor.
-/// lengths: Vector of sizes of the 0th dimension of tensors in the list.
-/// output_handle: The list.
-@inlinable
-public static func tensorListSplit<
-    ElementDtype: TensorFlowScalar,
-    ShapeType: BinaryInteger & TensorFlowScalar
->(
-  _ tensor: Tensor<ElementDtype>,
-  elementShape: Tensor<ShapeType>,
-  lengths: Tensor<Int64>
-) -> VariantHandle {
-  let op = TFE_Op("TensorListSplit")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  op.setAttr("shape_type", ShapeType.tensorFlowDataType)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(elementShape)
-  let _ = op.addInput(lengths)
-  return op.execute(Int(1))
-}
-
-/// Stacks all tensors in the list.
-///
-/// Requires that all tensors have the same shape.
-///
-/// input_handle: the input list
-/// tensor: the gathered result
-/// num_elements: optional. If not -1, the number of elements in the list.
-///
-@inlinable
-public static func tensorListStack<ElementDtype: TensorFlowScalar>(
-  inputHandle: VariantHandle,
-  elementShape: Tensor<Int32>,
-  numElements: Int64 = -1
-) -> Tensor<ElementDtype> {
-  let op = TFE_Op("TensorListStack")
-  op.setAttr("element_dtype", ElementDtype.tensorFlowDataType)
-  op.setAttr("num_elements", numElements)
-  let _ = op.addInput(inputHandle)
-  let _ = op.addInput(elementShape)
-  return op.execute(Int(1))
-}
-
-/// Adds sparse `updates` to an existing tensor according to `indices`.
-///
-/// This operation creates a new tensor by adding sparse `updates` to the passed
-/// in `tensor`.
-/// This operation is very similar to `tf.scatter_nd_add`, except that the updates
-/// are added onto an existing tensor (as opposed to a variable). If the memory
-/// for the existing tensor cannot be re-used, a copy is made and updated.
-///
-/// `indices` is an integer tensor containing indices into a new tensor of shape
-/// `shape`.  The last dimension of `indices` can be at most the rank of `shape`:
-///
-///     indices.shape[-1] <= shape.rank
-///
-/// The last dimension of `indices` corresponds to indices into elements
-/// (if `indices.shape[-1] = shape.rank`) or slices
-/// (if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
-/// `shape`.  `updates` is a tensor with shape
-///
-///     indices.shape[:-1] + shape[indices.shape[-1]:]
-///
-/// The simplest form of tensor_scatter_add is to add individual elements to a
-/// tensor by index. For example, say we want to add 4 elements in a rank-1
-/// tensor with 8 elements.
-///
-/// In Python, this scatter add operation would look like this:
-///
-/// ```python
-///     indices = tf.constant([[4], [3], [1], [7]])
-///     updates = tf.constant([9, 10, 11, 12])
-///     tensor = tf.ones([8], dtype=tf.int32)
-///     updated = tf.tensor_scatter_add(tensor, indices, updates)
-///     with tf.Session() as sess:
-///       print(sess.run(scatter))
-/// ```
-///
-/// The resulting tensor would look like this:
-///
-///     [1, 12, 1, 11, 10, 1, 1, 13]
-///
-/// We can also, insert entire slices of a higher rank tensor all at once. For
-/// example, if we wanted to insert two slices in the first dimension of a
-/// rank-3 tensor with two matrices of new values.
-///
-/// In Python, this scatter add operation would look like this:
-///
-/// ```python
-///     indices = tf.constant([[0], [2]])
-///     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
-///                             [7, 7, 7, 7], [8, 8, 8, 8]],
-///                            [[5, 5, 5, 5], [6, 6, 6, 6],
-///                             [7, 7, 7, 7], [8, 8, 8, 8]]])
-///     tensor = tf.ones([4, 4, 4])
-///     updated = tf.tensor_scatter_add(tensor, indices, updates)
-///     with tf.Session() as sess:
-///       print(sess.run(scatter))
-/// ```
-///
-/// The resulting tensor would look like this:
-///
-///     [[[6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8], [9, 9, 9, 9]],
-///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
-///      [[6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8], [9, 9, 9, 9]],
-///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
-///
-/// Note that on CPU, if an out of bound index is found, an error is returned.
-/// On GPU, if an out of bound index is found, the index is ignored.
-///
-/// - Parameters:
-///   - tensor: Tensor to copy/update.
-///   - indices: Index tensor.
-///   - updates: Updates to scatter into output.
-///
-/// - Output output: A new tensor copied from tensor and updates added according to the indices.
-@inlinable
-public static func tensorScatterAdd<
-    T: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  _ tensor: Tensor<T>,
-  indices: Tensor<Tindices>,
-  updates: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("TensorScatterAdd")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  return op.execute(Int(1))
-}
-
-/// Subtracts sparse `updates` from an existing tensor according to `indices`.
-///
-/// This operation creates a new tensor by subtracting sparse `updates` from the
-/// passed in `tensor`.
-/// This operation is very similar to `tf.scatter_nd_sub`, except that the updates
-/// are subtracted from an existing tensor (as opposed to a variable). If the memory
-/// for the existing tensor cannot be re-used, a copy is made and updated.
-///
-/// `indices` is an integer tensor containing indices into a new tensor of shape
-/// `shape`.  The last dimension of `indices` can be at most the rank of `shape`:
-///
-///     indices.shape[-1] <= shape.rank
-///
-/// The last dimension of `indices` corresponds to indices into elements
-/// (if `indices.shape[-1] = shape.rank`) or slices
-/// (if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
-/// `shape`.  `updates` is a tensor with shape
-///
-///     indices.shape[:-1] + shape[indices.shape[-1]:]
-///
-/// The simplest form of tensor_scatter_sub is to subtract individual elements
-/// from a tensor by index. For example, say we want to insert 4 scattered elements
-/// in a rank-1 tensor with 8 elements.
-///
-/// In Python, this scatter subtract operation would look like this:
-///
-/// ```python
-///     indices = tf.constant([[4], [3], [1], [7]])
-///     updates = tf.constant([9, 10, 11, 12])
-///     tensor = tf.ones([8], dtype=tf.int32)
-///     updated = tf.tensor_scatter_sub(tensor, indices, updates)
-///     with tf.Session() as sess:
-///       print(sess.run(scatter))
-/// ```
-///
-/// The resulting tensor would look like this:
-///
-///     [1, -10, 1, -9, -8, 1, 1, -11]
-///
-/// We can also, insert entire slices of a higher rank tensor all at once. For
-/// example, if we wanted to insert two slices in the first dimension of a
-/// rank-3 tensor with two matrices of new values.
-///
-/// In Python, this scatter add operation would look like this:
-///
-/// ```python
-///     indices = tf.constant([[0], [2]])
-///     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
-///                             [7, 7, 7, 7], [8, 8, 8, 8]],
-///                            [[5, 5, 5, 5], [6, 6, 6, 6],
-///                             [7, 7, 7, 7], [8, 8, 8, 8]]])
-///     tensor = tf.ones([4, 4, 4])
-///     updated = tf.tensor_scatter_sub(tensor, indices, updates)
-///     with tf.Session() as sess:
-///       print(sess.run(scatter))
-/// ```
-///
-/// The resulting tensor would look like this:
-///
-///     [[[-4, -4, -4, -4], [-5, -5, -5, -5], [-6, -6, -6, -6], [-7, -7, -7, -7]],
-///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
-///      [[-4, -4, -4, -4], [-5, -5, -5, -5], [-6, -6, -6, -6], [-7, -7, -7, -7]],
-///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
-///
-/// Note that on CPU, if an out of bound index is found, an error is returned.
-/// On GPU, if an out of bound index is found, the index is ignored.
-///
-/// - Parameters:
-///   - tensor: Tensor to copy/update.
-///   - indices: Index tensor.
-///   - updates: Updates to scatter into output.
-///
-/// - Output output: A new tensor copied from tensor and updates subtracted according to the indices.
-@inlinable
-public static func tensorScatterSub<
-    T: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  _ tensor: Tensor<T>,
-  indices: Tensor<Tindices>,
-  updates: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("TensorScatterSub")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  return op.execute(Int(1))
-}
-
-/// Scatter `updates` into an existing tensor according to `indices`.
-///
-/// This operation creates a new tensor by applying sparse `updates` to the passed
-/// in `tensor`.
-/// This operation is very similar to `tf.scatter_nd`, except that the updates are
-/// scattered onto an existing tensor (as opposed to a zero-tensor). If the memory
-/// for the existing tensor cannot be re-used, a copy is made and updated.
-///
-/// If `indices` contains duplicates, then their updates are accumulated (summed).
-///
-/// **WARNING**: The order in which updates are applied is nondeterministic, so the
-/// output will be nondeterministic if `indices` contains duplicates -- because
-/// of some numerical approximation issues, numbers summed in different order
-/// may yield different results.
-///
-/// `indices` is an integer tensor containing indices into a new tensor of shape
-/// `shape`.  The last dimension of `indices` can be at most the rank of `shape`:
-///
-///     indices.shape[-1] <= shape.rank
-///
-/// The last dimension of `indices` corresponds to indices into elements
-/// (if `indices.shape[-1] = shape.rank`) or slices
-/// (if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
-/// `shape`.  `updates` is a tensor with shape
-///
-///     indices.shape[:-1] + shape[indices.shape[-1]:]
-///
-/// The simplest form of scatter is to insert individual elements in a tensor by
-/// index. For example, say we want to insert 4 scattered elements in a rank-1
-/// tensor with 8 elements.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd1.png" alt>
-/// </div>
-///
-/// In Python, this scatter operation would look like this:
-///
-/// ```python
-///     indices = tf.constant([[4], [3], [1], [7]])
-///     updates = tf.constant([9, 10, 11, 12])
-///     tensor = tf.ones([8], dtype=tf.int32)
-///     updated = tf.tensor_scatter_update(tensor, indices, updates)
-///     with tf.Session() as sess:
-///       print(sess.run(scatter))
-/// ```
-///
-/// The resulting tensor would look like this:
-///
-///     [1, 11, 1, 10, 9, 1, 1, 12]
-///
-/// We can also, insert entire slices of a higher rank tensor all at once. For
-/// example, if we wanted to insert two slices in the first dimension of a
-/// rank-3 tensor with two matrices of new values.
-///
-/// In Python, this scatter operation would look like this:
-///
-/// ```python
-///     indices = tf.constant([[0], [2]])
-///     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
-///                             [7, 7, 7, 7], [8, 8, 8, 8]],
-///                            [[5, 5, 5, 5], [6, 6, 6, 6],
-///                             [7, 7, 7, 7], [8, 8, 8, 8]]])
-///     tensor = tf.ones([4, 4, 4])
-///     updated = tf.tensor_scatter_update(tensor, indices, updates)
-///     with tf.Session() as sess:
-///       print(sess.run(scatter))
-/// ```
-///
-/// The resulting tensor would look like this:
-///
-///     [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
-///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
-///      [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
-///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
-///
-/// Note that on CPU, if an out of bound index is found, an error is returned.
-/// On GPU, if an out of bound index is found, the index is ignored.
-///
-/// - Parameters:
-///   - tensor: Tensor to copy/update.
-///   - indices: Index tensor.
-///   - updates: Updates to scatter into output.
-///
-/// - Output output: A new tensor with the given shape and updates applied according
-///   to the indices.
-@inlinable
-public static func tensorScatterUpdate<
-    T: TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar
->(
-  _ tensor: Tensor<T>,
-  indices: Tensor<Tindices>,
-  updates: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("TensorScatterUpdate")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(updates)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that emits each dim-0 slice of `components` once.
-@inlinable
-public static func tensorSliceDataset<ToutputTypes: TensorArrayProtocol>(
-  components: ToutputTypes,
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("TensorSliceDataset")
-  op.setAttr("Toutput_types", components._typeList)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInputList(components)
-  return op.execute(Int(1))
-}
-
-/// Assign `value` to the sliced l-value reference of `input`.
-///
-/// The values of `value` are assigned to the positions in the tensor `input` that
-/// are selected by the slice parameters. The slice parameters `begin` `end`
-/// `strides` etc. work exactly as in `StridedSlice`.
-///
-/// NOTE this op currently does not support broadcasting and so `value`'s shape
-/// must be exactly the shape produced by the slice of `input`.
-@inlinable
-public static func tensorStridedSliceUpdate<
-    T: TensorFlowScalar,
-    Index: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  begin: Tensor<Index>,
-  end: Tensor<Index>,
-  strides: Tensor<Index>,
-  value: Tensor<T>,
-  beginMask: Int64 = 0,
-  endMask: Int64 = 0,
-  ellipsisMask: Int64 = 0,
-  newAxisMask: Int64 = 0,
-  shrinkAxisMask: Int64 = 0
-) -> Tensor<T> {
-  let op = TFE_Op("TensorStridedSliceUpdate")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Index", Index.tensorFlowDataType)
-  op.setAttr("begin_mask", beginMask)
-  op.setAttr("end_mask", endMask)
-  op.setAttr("ellipsis_mask", ellipsisMask)
-  op.setAttr("new_axis_mask", newAxisMask)
-  op.setAttr("shrink_axis_mask", shrinkAxisMask)
-  let _ = op.addInput(input)
-  let _ = op.addInput(begin)
-  let _ = op.addInput(end)
-  let _ = op.addInput(strides)
-  let _ = op.addInput(value)
-  return op.execute(Int(1))
-}
-
-/// Outputs a `Summary` protocol buffer with a tensor.
-///
-/// This op is being phased out in favor of TensorSummaryV2, which lets callers pass
-/// a tag as well as a serialized SummaryMetadata proto string that contains
-/// plugin-specific data. We will keep this op to maintain backwards compatibility.
-///
-/// - Parameter tensor: A tensor to serialize.
-///
-/// - Attrs:
-///   - description: A json-encoded SummaryDescription proto.
-///   - labels: An unused list of strings.
-///   - display_name: An unused string.
-@inlinable
-public static func tensorSummary<T: TensorFlowScalar>(
-  _ tensor: Tensor<T>,
-  description: String,
-  labels: [String],
-  displayName: String
-) -> StringTensor {
-  let op = TFE_Op("TensorSummary")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("description", description)
-  op.setAttr("labels", labels)
-  op.setAttr("display_name", displayName)
-  let _ = op.addInput(tensor)
-  return op.execute(Int(1))
-}
-
-/// Outputs a `Summary` protocol buffer with a tensor and per-plugin data.
-///
-/// - Parameters:
-///   - tag: A string attached to this summary. Used for organization in TensorBoard.
-///   - tensor: A tensor to serialize.
-///   - serialized_summary_metadata: A serialized SummaryMetadata proto. Contains plugin
-///     data.
-@inlinable
-public static func tensorSummaryV2<T: TensorFlowScalar>(
-  tag: StringTensor,
-  _ tensor: Tensor<T>,
-  serializedSummaryMetadata: StringTensor
-) -> StringTensor {
-  let op = TFE_Op("TensorSummaryV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(tag)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(serializedSummaryMetadata)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func testAttr<T: FloatingPoint & TensorFlowScalar>(
-) -> Tensor<T> {
-  let op = TFE_Op("TestAttr")
-  op.setAttr("T", T.tensorFlowDataType)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func testStringOutput(
-  _ input: Tensor<Float>
-) -> (output1: Tensor<Float>, output2: StringTensor) {
-  let op = TFE_Op("TestStringOutput")
-  let _ = op.addInput(input)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Creates a dataset that emits the lines of one or more text files.
-///
-/// - Parameters:
-///   - filenames: A scalar or a vector containing the name(s) of the file(s) to be
-///     read.
-///   - compression_type: A scalar containing either (i) the empty string (no
-///     compression), (ii) "ZLIB", or (iii) "GZIP".
-///   - buffer_size: A scalar containing the number of bytes to buffer.
-@inlinable
-public static func textLineDataset(
-  filenames: StringTensor,
-  compressionType: StringTensor,
-  bufferSize: Tensor<Int64>
-) -> VariantHandle {
-  let op = TFE_Op("TextLineDataset")
-  let _ = op.addInput(filenames)
-  let _ = op.addInput(compressionType)
-  let _ = op.addInput(bufferSize)
-  return op.execute(Int(1))
-}
-
-/// A Reader that outputs the lines of a file delimited by '\n'.
-///
-/// - Attrs:
-///   - skip_header_lines: Number of lines to skip from the beginning of every file.
-///   - container: If non-empty, this reader is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this reader is named in the given bucket
-///     with this shared_name. Otherwise, the node name is used instead.
-///
-/// - Output reader_handle: The handle to reference the Reader.
-@inlinable
-public static func textLineReaderV2(
-  skipHeaderLines: Int64 = 0,
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("TextLineReaderV2")
-  op.setAttr("skip_header_lines", skipHeaderLines)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// Generates labels for candidate sampling with a learned unigram distribution.
-///
-/// See explanations of candidate sampling and the data formats at
-/// go/candidate-sampling.
-///
-/// For each batch, this op picks a single set of sampled candidate labels.
-///
-/// The advantages of sampling candidates per-batch are simplicity and the
-/// possibility of efficient dense matrix multiplication. The disadvantage is that
-/// the sampled candidates must be chosen independently of the context and of the
-/// true labels.
-///
-/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
-///   IDs of the num_true target_classes in the corresponding original label.
-///
-/// - Attrs:
-///   - num_true: Number of true labels per context.
-///   - num_sampled: Number of candidates to randomly sample.
-///   - unique: If unique is true, we sample with rejection, so that all sampled
-///     candidates in a batch are unique. This requires some approximation to
-///     estimate the post-rejection sampling probabilities.
-///   - range_max: The sampler will sample integers from the interval [0, range_max).
-///   - seed: If either seed or seed2 are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: An second seed to avoid seed collision.
-///
-/// - Outputs:
-///   - sampled_candidates: A vector of length num_sampled, in which each element is
-///     the ID of a sampled candidate.
-///   - true_expected_count: A batch_size * num_true matrix, representing
-///     the number of times each candidate is expected to occur in a batch
-///     of sampled candidates. If unique=true, then this is a probability.
-///   - sampled_expected_count: A vector of length num_sampled, for each sampled
-///     candidate representing the number of times the candidate is expected
-///     to occur in a batch of sampled candidates.  If unique=true, then this is a
-///     probability.
-@inlinable
-public static func threadUnsafeUnigramCandidateSampler(
-  trueClasses: Tensor<Int64>,
-  numTrue: Int64,
-  numSampled: Int64,
-  unique: Bool,
-  rangeMax: Int64,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
-  let op = TFE_Op("ThreadUnsafeUnigramCandidateSampler")
-  op.setAttr("num_true", numTrue)
-  op.setAttr("num_sampled", numSampled)
-  op.setAttr("unique", unique)
-  op.setAttr("range_max", rangeMax)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(trueClasses)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Constructs a tensor by tiling a given tensor.
-///
-/// This operation creates a new tensor by replicating `input` `multiples` times.
-/// The output tensor's i'th dimension has `input.dims(i) * multiples[i]` elements,
-/// and the values of `input` are replicated `multiples[i]` times along the 'i'th
-/// dimension. For example, tiling `[a b c d]` by `[2]` produces
-/// `[a b c d a b c d]`.
-///
-/// - Parameters:
-///   - input: 1-D or higher.
-///   - multiples: 1-D. Length must be the same as the number of dimensions in `input`
-@inlinable
-public static func tile<
-    T: TensorFlowScalar,
-    Tmultiples: BinaryInteger & TensorFlowScalar
->(
-  _ input: Tensor<T>,
-  multiples: Tensor<Tmultiples>
-) -> Tensor<T> {
-  let op = TFE_Op("Tile")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tmultiples", Tmultiples.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(multiples)
-  return op.execute(Int(1))
-}
-
-/// Returns the gradient of `Tile`.
-///
-/// Since `Tile` takes an input and repeats the input `multiples` times
-/// along each dimension, `TileGrad` takes in `multiples` and aggregates
-/// each repeated tile of `input` into `output`.
-@inlinable
-public static func tileGrad<T: TensorFlowScalar>(
-  _ input: Tensor<T>,
-  multiples: Tensor<Int32>
-) -> Tensor<T> {
-  let op = TFE_Op("TileGrad")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(multiples)
-  return op.execute(Int(1))
-}
-
-/// Provides the time since epoch in seconds.
-///
-/// Returns the timestamp as a `float64` for seconds since the Unix epoch.
-///
-/// Note: the timestamp is computed when the op is executed, not when it is added
-/// to the graph.
-@inlinable
-public static func timestamp(
-) -> Tensor<Double> {
-  let op = TFE_Op("Timestamp")
-  
-  return op.execute(Int(1))
-}
-
-/// Finds values and indices of the `k` largest elements for the last dimension.
-///
-/// If the input is a vector (rank-1), finds the `k` largest entries in the vector
-/// and outputs their values and indices as vectors.  Thus `values[j]` is the
-/// `j`-th largest entry in `input`, and its index is `indices[j]`.
-///
-/// For matrices (resp. higher rank input), computes the top `k` entries in each
-/// row (resp. vector along the last dimension).  Thus,
-///
-///     values.shape = indices.shape = input.shape[:-1] + [k]
-///
-/// If two elements are equal, the lower-index element appears first.
-///
-/// If `k` varies dynamically, use `TopKV2` below.
-///
-/// - Parameter input: 1-D or higher with last dimension at least `k`.
-///
-/// - Attrs:
-///   - k: Number of top elements to look for along the last dimension (along each
-///     row for matrices).
-///   - sorted: If true the resulting `k` elements will be sorted by the values in
-///     descending order.
-///
-/// - Outputs:
-///   - values: The `k` largest elements along each last dimensional slice.
-///   - indices: The indices of `values` within the last dimension of `input`.
-@inlinable
-public static func topK<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  k: Int64,
-  sorted: Bool = true
-) -> (values: Tensor<T>, indices: Tensor<Int32>) {
-  let op = TFE_Op("TopK")
-  op.setAttr("k", k)
-  op.setAttr("sorted", sorted)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Finds values and indices of the `k` largest elements for the last dimension.
-///
-/// If the input is a vector (rank-1), finds the `k` largest entries in the vector
-/// and outputs their values and indices as vectors.  Thus `values[j]` is the
-/// `j`-th largest entry in `input`, and its index is `indices[j]`.
-///
-/// For matrices (resp. higher rank input), computes the top `k` entries in each
-/// row (resp. vector along the last dimension).  Thus,
-///
-///     values.shape = indices.shape = input.shape[:-1] + [k]
-///
-/// If two elements are equal, the lower-index element appears first.
-///
-/// - Parameters:
-///   - input: 1-D or higher with last dimension at least `k`.
-///   - k: 0-D.  Number of top elements to look for along the last dimension (along each
-///     row for matrices).
-///
-/// - Attr sorted: If true the resulting `k` elements will be sorted by the values in
-///   descending order.
-///
-/// - Outputs:
-///   - values: The `k` largest elements along each last dimensional slice.
-///   - indices: The indices of `values` within the last dimension of `input`.
-@inlinable
-public static func topKV2<T: Numeric & TensorFlowScalar>(
-  _ input: Tensor<T>,
-  k: Tensor<Int32>,
-  sorted: Bool = true
-) -> (values: Tensor<T>, indices: Tensor<Int32>) {
-  let op = TFE_Op("TopKV2")
-  op.setAttr("sorted", sorted)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  let _ = op.addInput(k)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Shuffle dimensions of x according to a permutation.
-///
-/// The output `y` has the same rank as `x`. The shapes of `x` and `y` satisfy:
-///   `y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]`
-@inlinable
-public static func transpose<
-    T: TensorFlowScalar,
-    Tperm: BinaryInteger & TensorFlowScalar
->(
-  _ x: Tensor<T>,
-  perm: Tensor<Tperm>
-) -> Tensor<T> {
-  let op = TFE_Op("Transpose")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tperm", Tperm.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(perm)
-  return op.execute(Int(1))
-}
-
-/// Solves tridiagonal systems of equations.
-///
-/// `diagonals` is a tensor of shape `[..., 3, M]` whose inner-most 2 dimensions
-/// represent matrices with three rows being the superdiagonal, diagonals, and
-/// subdiagonals, in order. The last element of the superdiagonal and the first
-/// element of the subdiagonal is ignored.
-/// `rhs` is a tensor of shape `[..., M, K]`, representing K right-hand sides per
-/// each left-hand side.
-/// The output is a tensor of shape `[..., M, K]` containing the solutions.
-///
-/// - Parameters:
-///   - diagonals: Shape is `[..., 3, M]`.
-///   - rhs: Shape is `[..., M, K]`.
-///
-/// - Output output: Shape is `[..., M, K]`.
-@inlinable
-public static func tridiagonalSolve<T: FloatingPoint & TensorFlowScalar>(
-  diagonals: Tensor<T>,
-  rhs: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("TridiagonalSolve")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(diagonals)
-  let _ = op.addInput(rhs)
-  return op.execute(Int(1))
-}
-
-/// Returns x / y element-wise for integer types.
-///
-/// Truncation designates that negative numbers will round fractional quantities
-/// toward zero. I.e. -7 / 5 = -1. This matches C semantics but it is different
-/// than Python semantics. See `FloorDiv` for a division function that matches
-/// Python Semantics.
-///
-/// *NOTE*: `TruncateDiv` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func truncateDiv<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("TruncateDiv")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns element-wise remainder of division. This emulates C semantics in that
-///
-/// the result here is consistent with a truncating divide. E.g. `truncate(x / y) *
-/// y + truncate_mod(x, y) = x`.
-///
-/// *NOTE*: `TruncateMod` supports broadcasting. More about broadcasting
-/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
-@inlinable
-public static func truncateMod<T: Numeric & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("TruncateMod")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Outputs random values from a truncated normal distribution.
-///
-/// The generated values follow a normal distribution with mean 0 and standard
-/// deviation 1, except that values whose magnitude is more than 2 standard
-/// deviations from the mean are dropped and re-picked.
-///
-/// - Parameter shape: The shape of the output tensor.
-///
-/// - Attrs:
-///   - seed: If either `seed` or `seed2` are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: A second seed to avoid seed collision.
-///   - dtype: The type of the output.
-///
-/// - Output output: A tensor of the specified shape filled with random truncated normal
-///   values.
-@inlinable
-public static func truncatedNormal<
-    Dtype: FloatingPoint & TensorFlowScalar,
-    T: BinaryInteger & TensorFlowScalar
->(
-  shape: Tensor<T>,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> Tensor<Dtype> {
-  let op = TFE_Op("TruncatedNormal")
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  op.setAttr("dtype", Dtype.tensorFlowDataType)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(shape)
-  return op.execute(Int(1))
-}
-
-/// Perform batches of RPC requests.
-///
-/// This op asynchronously performs either a single RPC request, or a batch
-/// of requests.  RPC requests are defined by three main parameters:
-///
-///   - `address` (the host+port or BNS address of the request)
-///   - `method` (the method name for the request)
-///   - `request` (the serialized proto string, or vector of strings,
-///      of the RPC request argument).
-///
-/// For example, if you have an RPC service running on port localhost:2345,
-/// and its interface is configured with the following proto declaration:
-///
-/// ```
-/// service MyService {
-///   rpc MyMethod(MyRequestProto) returns (MyResponseProto) {
-///   }
-/// };
-/// ```
-///
-/// then call this op with arguments:
-///
-/// ```
-/// address = "localhost:2345"
-/// method = "MyService/MyMethod"
-/// ```
-///
-/// The `request` tensor is a string tensor representing serialized `MyRequestProto`
-/// strings; and the output string tensor `response` will have the same shape
-/// and contain (upon successful completion) corresponding serialized
-/// `MyResponseProto` strings.
-///
-/// For example, to send a single, empty, `MyRequestProto`, call
-/// this op with `request = ""`.  To send 5 **parallel** empty requests,
-/// call this op with `request = ["", "", "", "", ""]`.
-///
-/// More generally, one can create a batch of `MyRequestProto` serialized protos
-/// from regular batched tensors using the `encode_proto` op, and convert
-/// the response `MyResponseProto` serialized protos to batched tensors
-/// using the `decode_proto` op.
-///
-/// **NOTE** Working with serialized proto strings is faster than instantiating
-/// actual proto objects in memory, so no performance degradation is expected
-/// compared to writing custom kernels for this workflow.
-///
-/// Unlike the standard `Rpc` op, if the connection fails or the remote worker
-/// returns an error status, this op does **not** reraise the exception.
-/// Instead, the `status_code` and `status_message` entry for the corresponding RPC
-/// call is set with the error returned from the RPC call.  The `response` tensor
-/// will contain valid response values for those minibatch entries whose RPCs did
-/// not fail; the rest of the entries will have empty strings.
-///
-/// - Parameters:
-///   - address: `0-D` or `1-D`.  The address (i.e. host_name:port) of the RPC server.
-///     If this tensor has more than 1 element, then multiple parallel rpc requests
-///     are sent.  This argument broadcasts with `method` and `request`.
-///   - method: `0-D` or `1-D`.  The method address on the RPC server.
-///     If this tensor has more than 1 element, then multiple parallel rpc requests
-///     are sent.  This argument broadcasts with `address` and `request`.
-///   - request: `0-D` or `1-D`.  Serialized proto strings: the rpc request argument.
-///     If this tensor has more than 1 element, then multiple parallel rpc requests
-///     are sent.  This argument broadcasts with `address` and `method`.
-///
-/// - Attrs:
-///   - protocol: RPC protocol to use.  Empty string means use the default protocol.
-///     Options include 'grpc'.
-///   - fail_fast: `boolean`. If `true` (default), then failures to connect
-///     (i.e., the server does not immediately respond) cause an RPC failure.
-///   - timeout_in_ms: `int`. If `0` (default), then the kernel will run the RPC
-///     request and only time out if the RPC deadline passes or the session times out.
-///     If this value is greater than `0`, then the op will raise an exception if
-///     the RPC takes longer than `timeout_in_ms`.
-///
-/// - Outputs:
-///   - response: Same shape as `request`. Serialized proto strings: the rpc responses.
-///   - status_code: Same shape as `request`.  Values correspond to tensorflow Status enum codes.
-///   - status_message: Same shape as `request`.  Values correspond to Status messages
-///     returned from the RPC calls.
-@inlinable
-public static func tryRpc(
-  address: StringTensor,
-  method: StringTensor,
-  request: StringTensor,
-  protocol_: String,
-  failFast: Bool = true,
-  timeoutInMs: Int64 = 0
-) -> (response: StringTensor, statusCode: Tensor<Int32>, statusMessage: StringTensor) {
-  let op = TFE_Op("TryRpc")
-  op.setAttr("protocol", protocol_)
-  op.setAttr("fail_fast", failFast)
-  op.setAttr("timeout_in_ms", timeoutInMs)
-  let _ = op.addInput(address)
-  let _ = op.addInput(method)
-  let _ = op.addInput(request)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-@inlinable
-public static func twoFloatInputs(
-  _ a: Tensor<Float>,
-  _ b: Tensor<Float>
-) {
-  let op = TFE_Op("TwoFloatInputs")
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  op.execute()
-}
-
-@inlinable
-public static func twoFloatInputsFloatOutput(
-  _ a: Tensor<Float>,
-  _ b: Tensor<Float>
-) -> Tensor<Float> {
-  let op = TFE_Op("TwoFloatInputsFloatOutput")
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func twoFloatInputsIntOutput(
-  _ a: Tensor<Float>,
-  _ b: Tensor<Float>
-) -> Tensor<Int32> {
-  let op = TFE_Op("TwoFloatInputsIntOutput")
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func twoFloatOutputs(
-) -> (a: Tensor<Float>, b: Tensor<Float>) {
-  let op = TFE_Op("TwoFloatOutputs")
-  
-  return op.execute(Int(1), Int(1))
-}
-
-@inlinable
-public static func twoIntInputs(
-  _ a: Tensor<Int32>,
-  _ b: Tensor<Int32>
-) {
-  let op = TFE_Op("TwoIntInputs")
-  let _ = op.addInput(a)
-  let _ = op.addInput(b)
-  op.execute()
-}
-
-@inlinable
-public static func twoIntOutputs(
-) -> (a: Tensor<Int32>, b: Tensor<Int32>) {
-  let op = TFE_Op("TwoIntOutputs")
-  
-  return op.execute(Int(1), Int(1))
-}
-
-@inlinable
-public static func typeList<T: TensorArrayProtocol>(
-  _ a: T
-) {
-  let op = TFE_Op("TypeList")
-  op.setAttr("T", a._typeList)
-  let _ = op.addInputList(a)
-  op.execute()
-}
-
-@inlinable
-public static func typeListRestrict<T: TensorArrayProtocol>(
-  _ a: T
-) {
-  let op = TFE_Op("TypeListRestrict")
-  op.setAttr("T", a._typeList)
-  let _ = op.addInputList(a)
-  op.execute()
-}
-
-@inlinable
-public static func typeListTwice<T: TensorArrayProtocol>(
-  _ a: T,
-  _ b: T
-) {
-  let op = TFE_Op("TypeListTwice")
-  op.setAttr("T", a._typeList)
-  let _ = op.addInputList(a)
-  let _ = op.addInputList(b)
-  op.execute()
-}
-
-@inlinable
-public static func unary<T: TensorFlowScalar>(
-  _ a: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Unary")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(a)
-  return op.execute(Int(1))
-}
-
-/// Reverses the operation of Batch for a single output Tensor.
-///
-/// An instance of Unbatch either receives an empty batched_tensor, in which case it
-/// asynchronously waits until the values become available from a concurrently
-/// running instance of Unbatch with the same container and shared_name, or receives
-/// a non-empty batched_tensor in which case it finalizes all other concurrently
-/// running instances and outputs its own element from the batch.
-///
-/// batched_tensor: The possibly transformed output of Batch. The size of the first
-///  dimension should remain unchanged by the transformations for the operation to
-///  work.
-/// batch_index: The matching batch_index obtained from Batch.
-/// id: The id scalar emitted by Batch.
-/// unbatched_tensor: The Tensor corresponding to this execution.
-/// timeout_micros: Maximum amount of time (in microseconds) to wait to receive the
-///  batched input tensor associated with a given invocation of the op.
-/// container: Container to control resource sharing.
-/// shared_name: Instances of Unbatch with the same container and shared_name are
-///  assumed to possibly belong to the same batch. If left empty, the op name will
-///  be used as the shared name.
-@inlinable
-public static func unbatch<T: TensorFlowScalar>(
-  batchedTensor: Tensor<T>,
-  batchIndex: Tensor<Int64>,
-  id: Tensor<Int64>,
-  timeoutMicros: Int64,
-  container: String,
-  sharedName: String
-) -> Tensor<T> {
-  let op = TFE_Op("Unbatch")
-  op.setAttr("timeout_micros", timeoutMicros)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(batchedTensor)
-  let _ = op.addInput(batchIndex)
-  let _ = op.addInput(id)
-  return op.execute(Int(1))
-}
-
-/// Gradient of Unbatch.
-///
-/// Acts like Batch but using the given batch_index index of batching things as they
-/// become available. This ensures that the gradients are propagated back in the
-/// same session which did the forward pass.
-///
-/// original_input: The input to the Unbatch operation this is the gradient of.
-/// batch_index: The batch_index given to the Unbatch operation this is the gradient
-/// of.
-/// grad: The downstream gradient.
-/// id: The id scalar emitted by Batch.
-/// batched_grad: The return value, either an empty tensor or the batched gradient.
-/// container: Container to control resource sharing.
-/// shared_name: Instances of UnbatchGrad with the same container and shared_name
-///  are assumed to possibly belong to the same batch. If left empty, the op name
-///  will be used as the shared name.
-@inlinable
-public static func unbatchGrad<T: TensorFlowScalar>(
-  originalInput: Tensor<T>,
-  batchIndex: Tensor<Int64>,
-  grad: Tensor<T>,
-  id: Tensor<Int64>,
-  container: String,
-  sharedName: String
-) -> Tensor<T> {
-  let op = TFE_Op("UnbatchGrad")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(originalInput)
-  let _ = op.addInput(batchIndex)
-  let _ = op.addInput(grad)
-  let _ = op.addInput(id)
-  return op.execute(Int(1))
-}
-
-/// Decodes each string in `input` into a sequence of Unicode code points.
-///
-/// The character codepoints for all strings are returned using a single vector
-/// `char_values`, with strings expanded to characters in row-major order.
-///
-/// The `row_splits` tensor indicates where the codepoints for
-/// each input string begin and end within the `char_values` tensor.
-/// In particular, the values for the `i`th
-/// string (in row-major order) are stored in the slice
-/// `[row_splits[i]:row_splits[i+1]]`. Thus:
-///
-/// * `char_values[row_splits[i]+j]` is the Unicode codepoint for the `j`th
-///   character in the `i`th string (in row-major order).
-/// * `row_splits[i+1] - row_splits[i]` is the number of characters in the `i`th
-///   string (in row-major order).
-///
-/// - Parameter input: The text to be decoded. Can have any shape. Note that the output is flattened
-///   to a vector of char values.
-///
-/// - Attrs:
-///   - input_encoding: Text encoding of the input strings. This is any of the encodings supported
-///     by ICU ucnv algorithmic converters. Examples: `"UTF-16", "US ASCII", "UTF-8"`.
-///   - errors: Error handling policy when there is invalid formatting found in the input.
-///     The value of 'strict' will cause the operation to produce a InvalidArgument
-///     error on any invalid input formatting. A value of 'replace' (the default) will
-///     cause the operation to replace any invalid formatting in the input with the
-///     `replacement_char` codepoint. A value of 'ignore' will cause the operation to
-///     skip any invalid formatting in the input and produce no corresponding output
-///     character.
-///   - replacement_char: The replacement character codepoint to be used in place of any invalid
-///     formatting in the input when `errors='replace'`. Any valid unicode codepoint may
-///     be used. The default value is the default unicode replacement character is
-///     0xFFFD or U+65533.)
-///   - replace_control_characters: Whether to replace the C0 control characters (00-1F) with the
-///     `replacement_char`. Default is false.
-///
-/// - Outputs:
-///   - row_splits: A 1D int32 tensor containing the row splits.
-///   - char_values: A 1D int32 Tensor containing the decoded codepoints.
-@inlinable
-public static func unicodeDecode(
-  _ input: StringTensor,
-  inputEncoding: String,
-  errors: Errors = .replace,
-  replacementChar: Int64 = 65533,
-  replaceControlCharacters: Bool = false
-) -> (rowSplits: Tensor<Int64>, charValues: Tensor<Int32>) {
-  let op = TFE_Op("UnicodeDecode")
-  op.setAttr("input_encoding", inputEncoding)
-  op.setAttr("errors", errors.cName)
-  op.setAttr("replacement_char", replacementChar)
-  op.setAttr("replace_control_characters", replaceControlCharacters)
-  let _ = op.addInput(input)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Decodes each string in `input` into a sequence of Unicode code points.
-///
-/// The character codepoints for all strings are returned using a single vector
-/// `char_values`, with strings expanded to characters in row-major order.
-/// Similarly, the character start byte offsets are returned using a single vector
-/// `char_to_byte_starts`, with strings expanded in row-major order.
-///
-/// The `row_splits` tensor indicates where the codepoints and start offsets for
-/// each input string begin and end within the `char_values` and
-/// `char_to_byte_starts` tensors.  In particular, the values for the `i`th
-/// string (in row-major order) are stored in the slice
-/// `[row_splits[i]:row_splits[i+1]]`. Thus:
-///
-/// * `char_values[row_splits[i]+j]` is the Unicode codepoint for the `j`th
-///   character in the `i`th string (in row-major order).
-/// * `char_to_bytes_starts[row_splits[i]+j]` is the start byte offset for the `j`th
-///   character in the `i`th string (in row-major order).
-/// * `row_splits[i+1] - row_splits[i]` is the number of characters in the `i`th
-///   string (in row-major order).
-///
-/// - Parameter input: The text to be decoded. Can have any shape. Note that the output is flattened
-///   to a vector of char values.
-///
-/// - Attrs:
-///   - input_encoding: Text encoding of the input strings. This is any of the encodings supported
-///     by ICU ucnv algorithmic converters. Examples: `"UTF-16", "US ASCII", "UTF-8"`.
-///   - errors: Error handling policy when there is invalid formatting found in the input.
-///     The value of 'strict' will cause the operation to produce a InvalidArgument
-///     error on any invalid input formatting. A value of 'replace' (the default) will
-///     cause the operation to replace any invalid formatting in the input with the
-///     `replacement_char` codepoint. A value of 'ignore' will cause the operation to
-///     skip any invalid formatting in the input and produce no corresponding output
-///     character.
-///   - replacement_char: The replacement character codepoint to be used in place of any invalid
-///     formatting in the input when `errors='replace'`. Any valid unicode codepoint may
-///     be used. The default value is the default unicode replacement character is
-///     0xFFFD or U+65533.)
-///   - replace_control_characters: Whether to replace the C0 control characters (00-1F) with the
-///     `replacement_char`. Default is false.
-///
-/// - Outputs:
-///   - row_splits: A 1D int32 tensor containing the row splits.
-///   - char_values: A 1D int32 Tensor containing the decoded codepoints.
-///   - char_to_byte_starts: A 1D int32 Tensor containing the byte index in the input string where each
-///     character in `char_values` starts.
-@inlinable
-public static func unicodeDecodeWithOffsets(
-  _ input: StringTensor,
-  inputEncoding: String,
-  errors: Errors = .replace,
-  replacementChar: Int64 = 65533,
-  replaceControlCharacters: Bool = false
-) -> (rowSplits: Tensor<Int64>, charValues: Tensor<Int32>, charToByteStarts: Tensor<Int64>) {
-  let op = TFE_Op("UnicodeDecodeWithOffsets")
-  op.setAttr("input_encoding", inputEncoding)
-  op.setAttr("errors", errors.cName)
-  op.setAttr("replacement_char", replacementChar)
-  op.setAttr("replace_control_characters", replaceControlCharacters)
-  let _ = op.addInput(input)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Encode a tensor of ints into unicode strings.
-///
-/// Returns a vector of strings, where `output[i]` is constructed by encoding the
-/// Unicode codepoints in `input_values[input_splits[i]:input_splits[i+1]]`
-/// using `output_encoding`.
-///
-/// ---
-///
-/// Example:
-///
-/// ```
-/// input_values = [72, 101, 108, 108, 111, 87, 111, 114, 108, 100]
-/// input_splits = [0, 5, 10]
-/// output_encoding = 'UTF-8'
-///
-/// output = ['Hello', 'World']
-/// ```
-///
-/// - Parameters:
-///   - input_values: A 1D tensor containing the unicode codepoints that should be encoded.
-///   - input_splits: A 1D tensor specifying how the unicode codepoints should be split into strings.
-///     In particular, `output[i]` is constructed by encoding the codepoints in the
-///     slice `input_values[input_splits[i]:input_splits[i+1]]`.
-///
-/// - Attrs:
-///   - errors: Error handling policy when there is invalid formatting found in the input.
-///     The value of 'strict' will cause the operation to produce a InvalidArgument
-///     error on any invalid input formatting. A value of 'replace' (the default) will
-///     cause the operation to replace any invalid formatting in the input with the
-///     `replacement_char` codepoint. A value of 'ignore' will cause the operation to
-///     skip any invalid formatting in the input and produce no corresponding output
-///     character.
-///   - output_encoding: Unicode encoding of the output strings. Valid encodings are: `"UTF-8",
-///     "UTF-16-BE", and "UTF-32-BE"`.
-///   - replacement_char: The replacement character codepoint to be used in place of any invalid
-///     formatting in the input when `errors='replace'`. Any valid unicode codepoint may
-///     be used. The default value is the default unicode replacement character is
-///     0xFFFD (U+65533).
-///
-/// - Output output: The 1-D Tensor of strings encoded from the provided unicode codepoints.
-@inlinable
-public static func unicodeEncode(
-  inputValues: Tensor<Int32>,
-  inputSplits: Tensor<Int64>,
-  errors: Errors = .replace,
-  outputEncoding: OutputEncoding,
-  replacementChar: Int64 = 65533
-) -> StringTensor {
-  let op = TFE_Op("UnicodeEncode")
-  op.setAttr("errors", errors.cName)
-  op.setAttr("output_encoding", outputEncoding.cName)
-  op.setAttr("replacement_char", replacementChar)
-  let _ = op.addInput(inputValues)
-  let _ = op.addInput(inputSplits)
-  return op.execute(Int(1))
-}
-
-/// Determine the script codes of a given tensor of Unicode integer code points.
-///
-/// This operation converts Unicode code points to script codes corresponding to
-/// each code point. Script codes correspond to International Components for
-/// Unicode (ICU) UScriptCode values. See http://icu-project.org/apiref/icu4c/uscript_8h.html.
-/// Returns -1 (USCRIPT_INVALID_CODE) for invalid codepoints. Output shape will
-/// match input shape.
-///
-/// - Parameter input: A Tensor of int32 Unicode code points.
-///
-/// - Output output: A Tensor of int32 script codes corresponding to each input code point.
-@inlinable
-public static func unicodeScript(
-  _ input: Tensor<Int32>
-) -> Tensor<Int32> {
-  let op = TFE_Op("UnicodeScript")
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Transcode the input text from a source encoding to a destination encoding.
-///
-/// The input is a string tensor of any shape. The output is a string tensor of
-/// the same shape containing the transcoded strings. Output strings are always
-/// valid unicode. If the input contains invalid encoding positions, the
-/// `errors` attribute sets the policy for how to deal with them. If the default
-/// error-handling policy is used, invalid formatting will be substituted in the
-/// output by the `replacement_char`. If the errors policy is to `ignore`, any
-/// invalid encoding positions in the input are skipped and not included in the
-/// output. If it set to `strict` then any invalid formatting will result in an
-/// InvalidArgument error.
-///
-/// This operation can be used with `output_encoding = input_encoding` to enforce
-/// correct formatting for inputs even if they are already in the desired encoding.
-///
-/// If the input is prefixed by a Byte Order Mark needed to determine encoding
-/// (e.g. if the encoding is UTF-16 and the BOM indicates big-endian), then that
-/// BOM will be consumed and not emitted into the output. If the input encoding
-/// is marked with an explicit endianness (e.g. UTF-16-BE), then the BOM is
-/// interpreted as a non-breaking-space and is preserved in the output (including
-/// always for UTF-8).
-///
-/// The end result is that if the input is marked as an explicit endianness the
-/// transcoding is faithful to all codepoints in the source. If it is not marked
-/// with an explicit endianness, the BOM is not considered part of the string itself
-/// but as metadata, and so is not preserved in the output.
-///
-/// - Parameter input: The text to be processed. Can have any shape.
-///
-/// - Attrs:
-///   - input_encoding: Text encoding of the input strings. This is any of the encodings supported
-///     by ICU ucnv algorithmic converters. Examples: `"UTF-16", "US ASCII", "UTF-8"`.
-///   - output_encoding: The unicode encoding to use in the output. Must be one of
-///     `"UTF-8", "UTF-16-BE", "UTF-32-BE"`. Multi-byte encodings will be big-endian.
-///   - errors: Error handling policy when there is invalid formatting found in the input.
-///     The value of 'strict' will cause the operation to produce a InvalidArgument
-///     error on any invalid input formatting. A value of 'replace' (the default) will
-///     cause the operation to replace any invalid formatting in the input with the
-///     `replacement_char` codepoint. A value of 'ignore' will cause the operation to
-///     skip any invalid formatting in the input and produce no corresponding output
-///     character.
-///   - replacement_char: The replacement character codepoint to be used in place of any invalid
-///     formatting in the input when `errors='replace'`. Any valid unicode codepoint may
-///     be used. The default value is the default unicode replacement character is
-///     0xFFFD or U+65533.)
-///
-///     Note that for UTF-8, passing a replacement character expressible in 1 byte, such
-///     as ' ', will preserve string alignment to the source since invalid bytes will be
-///     replaced with a 1-byte replacement. For UTF-16-BE and UTF-16-LE, any 1 or 2 byte
-///     replacement character will preserve byte alignment to the source.
-///   - replace_control_characters: Whether to replace the C0 control characters (00-1F) with the
-///     `replacement_char`. Default is false.
-///
-/// - Output output: A string tensor containing unicode text encoded using `output_encoding`.
-@inlinable
-public static func unicodeTranscode(
-  _ input: StringTensor,
-  inputEncoding: String,
-  outputEncoding: OutputEncoding,
-  errors: Errors = .replace,
-  replacementChar: Int64 = 65533,
-  replaceControlCharacters: Bool = false
-) -> StringTensor {
-  let op = TFE_Op("UnicodeTranscode")
-  op.setAttr("input_encoding", inputEncoding)
-  op.setAttr("output_encoding", outputEncoding.cName)
-  op.setAttr("errors", errors.cName)
-  op.setAttr("replacement_char", replacementChar)
-  op.setAttr("replace_control_characters", replaceControlCharacters)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Generates labels for candidate sampling with a uniform distribution.
-///
-/// See explanations of candidate sampling and the data formats at
-/// go/candidate-sampling.
-///
-/// For each batch, this op picks a single set of sampled candidate labels.
-///
-/// The advantages of sampling candidates per-batch are simplicity and the
-/// possibility of efficient dense matrix multiplication. The disadvantage is that
-/// the sampled candidates must be chosen independently of the context and of the
-/// true labels.
-///
-/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
-///   IDs of the num_true target_classes in the corresponding original label.
-///
-/// - Attrs:
-///   - num_true: Number of true labels per context.
-///   - num_sampled: Number of candidates to randomly sample.
-///   - unique: If unique is true, we sample with rejection, so that all sampled
-///     candidates in a batch are unique. This requires some approximation to
-///     estimate the post-rejection sampling probabilities.
-///   - range_max: The sampler will sample integers from the interval [0, range_max).
-///   - seed: If either seed or seed2 are set to be non-zero, the random number
-///     generator is seeded by the given seed.  Otherwise, it is seeded by a
-///     random seed.
-///   - seed2: An second seed to avoid seed collision.
-///
-/// - Outputs:
-///   - sampled_candidates: A vector of length num_sampled, in which each element is
-///     the ID of a sampled candidate.
-///   - true_expected_count: A batch_size * num_true matrix, representing
-///     the number of times each candidate is expected to occur in a batch
-///     of sampled candidates. If unique=true, then this is a probability.
-///   - sampled_expected_count: A vector of length num_sampled, for each sampled
-///     candidate representing the number of times the candidate is expected
-///     to occur in a batch of sampled candidates.  If unique=true, then this is a
-///     probability.
-@inlinable
-public static func uniformCandidateSampler(
-  trueClasses: Tensor<Int64>,
-  numTrue: Int64,
-  numSampled: Int64,
-  unique: Bool,
-  rangeMax: Int64,
-  seed: Int64 = 0,
-  seed2: Int64 = 0
-) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
-  let op = TFE_Op("UniformCandidateSampler")
-  op.setAttr("num_true", numTrue)
-  op.setAttr("num_sampled", numSampled)
-  op.setAttr("unique", unique)
-  op.setAttr("range_max", rangeMax)
-  op.setAttr("seed", seed)
-  op.setAttr("seed2", seed2)
-  let _ = op.addInput(trueClasses)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Finds unique elements in a 1-D tensor.
-///
-/// This operation returns a tensor `y` containing all of the unique elements of `x`
-/// sorted in the same order that they occur in `x`. This operation also returns a
-/// tensor `idx` the same size as `x` that contains the index of each value of `x`
-/// in the unique output `y`. In other words:
-///
-/// `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
-///
-/// For example:
-///
-/// ```
-/// # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
-/// y, idx = unique(x)
-/// y ==> [1, 2, 4, 7, 8]
-/// idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
-/// ```
-///
-/// - Parameter x: 1-D.
-///
-/// - Outputs:
-///   - y: 1-D.
-///   - idx: 1-D.
-@inlinable
-public static func unique<
-    T: TensorFlowScalar,
-    OutIdx: BinaryInteger & TensorFlowScalar
->(
-  _ x: Tensor<T>
-) -> (y: Tensor<T>, idx: Tensor<OutIdx>) {
-  let op = TFE_Op("Unique")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_idx", OutIdx.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Finds unique elements along an axis of a tensor.
-///
-/// This operation either returns a tensor `y` containing unique elements
-/// along the `axis` of a tensor. The returned unique elements is sorted
-/// in the same order as they occur along `axis` in `x`.
-/// This operation also returns a tensor `idx` that is the same size as
-/// the number of the elements in `x` along the `axis` dimension. It
-/// contains the index in the unique output `y`.
-/// In other words, for an `1-D` tensor `x` with `axis = None:
-///
-/// `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
-///
-/// For example:
-///
-/// ```
-/// # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
-/// y, idx = unique(x)
-/// y ==> [1, 2, 4, 7, 8]
-/// idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
-/// ```
-///
-/// For an `2-D` tensor `x` with `axis = 0`:
-///
-/// ```
-/// # tensor 'x' is [[1, 0, 0],
-/// #                [1, 0, 0],
-/// #                [2, 0, 0]]
-/// y, idx = unique(x, axis=0)
-/// y ==> [[1, 0, 0],
-///        [2, 0, 0]]
-/// idx ==> [0, 0, 1]
-/// ```
-///
-/// For an `2-D` tensor `x` with `axis = 1`:
-///
-/// ```
-/// # tensor 'x' is [[1, 0, 0],
-/// #                [1, 0, 0],
-/// #                [2, 0, 0]]
-/// y, idx = unique(x, axis=1)
-/// y ==> [[1, 0],
-///        [1, 0],
-///        [2, 0]]
-/// idx ==> [0, 1, 1]
-/// ```
-///
-/// - Parameters:
-///   - x: A `Tensor`.
-///   - axis: A `Tensor` of type `int32` (default: None). The axis of the Tensor to
-///     find the unique elements.
-///
-/// - Outputs:
-///   - y: A `Tensor`. Unique elements along the `axis` of `Tensor` x.
-///   - idx: A 1-D Tensor. Has the same type as x that contains the index of each
-///     value of x in the output y.
-@inlinable
-public static func uniqueV2<
-    T: TensorFlowScalar,
-    Taxis: BinaryInteger & TensorFlowScalar,
-    OutIdx: BinaryInteger & TensorFlowScalar
->(
-  _ x: Tensor<T>,
-  axis: Tensor<Taxis>
-) -> (y: Tensor<T>, idx: Tensor<OutIdx>) {
-  let op = TFE_Op("UniqueV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Taxis", Taxis.tensorFlowDataType)
-  op.setAttr("out_idx", OutIdx.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(axis)
-  return op.execute(Int(1), Int(1))
-}
-
-/// Finds unique elements in a 1-D tensor.
-///
-/// This operation returns a tensor `y` containing all of the unique elements of `x`
-/// sorted in the same order that they occur in `x`. This operation also returns a
-/// tensor `idx` the same size as `x` that contains the index of each value of `x`
-/// in the unique output `y`. Finally, it returns a third tensor `count` that
-/// contains the count of each element of `y` in `x`. In other words:
-///
-/// `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
-///
-/// For example:
-///
-/// ```
-/// # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
-/// y, idx, count = unique_with_counts(x)
-/// y ==> [1, 2, 4, 7, 8]
-/// idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
-/// count ==> [2, 1, 3, 1, 2]
-/// ```
-///
-/// - Parameter x: 1-D.
-///
-/// - Outputs:
-///   - y: 1-D.
-///   - idx: 1-D.
-///   - count: 1-D.
-@inlinable
-public static func uniqueWithCounts<
-    T: TensorFlowScalar,
-    OutIdx: BinaryInteger & TensorFlowScalar
->(
-  _ x: Tensor<T>
-) -> (y: Tensor<T>, idx: Tensor<OutIdx>, count: Tensor<OutIdx>) {
-  let op = TFE_Op("UniqueWithCounts")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_idx", OutIdx.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Finds unique elements along an axis of a tensor.
-///
-/// This operation either returns a tensor `y` containing unique elements
-/// along the `axis` of a tensor. The returned unique elements is sorted
-/// in the same order as they occur along `axis` in `x`.
-/// This operation also returns a tensor `idx` and a tensor `count`
-/// that are the same size as the number of the elements in `x` along the
-/// `axis` dimension. The `idx` contains the index in the unique output `y`
-/// and the `count` contains the count in the unique output `y`.
-/// In other words, for an `1-D` tensor `x` with `axis = None:
-///
-/// `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
-///
-/// For example:
-///
-/// ```
-/// # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
-/// y, idx, count = unique_with_counts(x)
-/// y ==> [1, 2, 4, 7, 8]
-/// idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
-/// count ==> [2, 1, 3, 1, 2]
-/// ```
-///
-/// For an `2-D` tensor `x` with `axis = 0`:
-///
-/// ```
-/// # tensor 'x' is [[1, 0, 0],
-/// #                [1, 0, 0],
-/// #                [2, 0, 0]]
-/// y, idx, count = unique_with_counts(x, axis=0)
-/// y ==> [[1, 0, 0],
-///        [2, 0, 0]]
-/// idx ==> [0, 0, 1]
-/// count ==> [2, 1]
-/// ```
-///
-/// For an `2-D` tensor `x` with `axis = 1`:
-///
-/// ```
-/// # tensor 'x' is [[1, 0, 0],
-/// #                [1, 0, 0],
-/// #                [2, 0, 0]]
-/// y, idx, count = unique_with_counts(x, axis=1)
-/// y ==> [[1, 0],
-///        [1, 0],
-///        [2, 0]]
-/// idx ==> [0, 1, 1]
-/// count ==> [1, 2]
-/// ```
-///
-/// - Parameters:
-///   - x: A `Tensor`.
-///   - axis: A `Tensor` of type `int32` (default: None). The axis of the Tensor to
-///     find the unique elements.
-///
-/// - Outputs:
-///   - y: A `Tensor`. Unique elements along the `axis` of `Tensor` x.
-///   - idx: A 1-D Tensor. Has the same type as x that contains the index of each
-///     value of x in the output y.
-///   - count: A 1-D Tensor. The count of each value of x in the output y.
-@inlinable
-public static func uniqueWithCountsV2<
-    T: TensorFlowScalar,
-    Taxis: BinaryInteger & TensorFlowScalar,
-    OutIdx: BinaryInteger & TensorFlowScalar
->(
-  _ x: Tensor<T>,
-  axis: Tensor<Taxis>
-) -> (y: Tensor<T>, idx: Tensor<OutIdx>, count: Tensor<OutIdx>) {
-  let op = TFE_Op("UniqueWithCountsV2")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Taxis", Taxis.tensorFlowDataType)
-  op.setAttr("out_idx", OutIdx.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(axis)
-  return op.execute(Int(1), Int(1), Int(1))
-}
-
-/// Unpacks a given dimension of a rank-`R` tensor into `num` rank-`(R-1)` tensors.
-///
-/// Unpacks `num` tensors from `value` by chipping it along the `axis` dimension.
-/// For example, given a tensor of shape `(A, B, C, D)`;
-///
-/// If `axis == 0` then the i'th tensor in `output` is the slice `value[i, :, :, :]`
-///   and each tensor in `output` will have shape `(B, C, D)`. (Note that the
-///   dimension unpacked along is gone, unlike `split`).
-///
-/// If `axis == 1` then the i'th tensor in `output` is the slice `value[:, i, :, :]`
-///   and each tensor in `output` will have shape `(A, C, D)`.
-/// Etc.
-///
-/// This is the opposite of `pack`.
-///
-/// - Parameter value: 1-D or higher, with `axis` dimension size equal to `num`.
-///
-/// - Attr axis: Dimension along which to unpack.  Negative values wrap around, so the
-///   valid range is `[-R, R)`.
-///
-/// - Output output: The list of tensors unpacked from `value`.
-@inlinable
-public static func unpack<T: TensorFlowScalar>(
-  value: Tensor<T>,
-  num: Int64,
-  axis: Int64 = 0
-) -> [Tensor<T>] {
-  let op = TFE_Op("Unpack")
-  op.setAttr("num", num)
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("axis", axis)
-  let _ = op.addInput(value)
-  return op.execute(Int(num))
-}
-
-/// Converts a flat index or array of flat indices into a tuple of
-///
-/// coordinate arrays.
-///
-/// @compatibility(numpy)
-/// Equivalent to np.unravel_index
-/// @end_compatibility
-///
-/// - Parameters:
-///   - indices: An 0-D or 1-D `int` Tensor whose elements are indices into the
-///     flattened version of an array of dimensions dims.
-///   - dims: An 1-D `int` Tensor. The shape of the array to use for unraveling
-///     indices.
-///
-/// - Output output: An 2-D (or 1-D if indices is 0-D) tensor where each row has the
-///   same shape as the indices array.
-@inlinable
-public static func unravelIndex<Tidx: BinaryInteger & TensorFlowScalar>(
-  indices: Tensor<Tidx>,
-  dims: Tensor<Tidx>
-) -> Tensor<Tidx> {
-  let op = TFE_Op("UnravelIndex")
-  op.setAttr("Tidx", Tidx.tensorFlowDataType)
-  let _ = op.addInput(indices)
-  let _ = op.addInput(dims)
-  return op.execute(Int(1))
-}
-
-/// Computes the maximum along segments of a tensor.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
-/// for an explanation of segments.
-///
-/// This operator is similar to the unsorted segment sum operator found
-/// [(here)](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
-/// Instead of computing the sum over segments, it computes the maximum such that:
-///
-/// \\(output_i = \max_{j...} data[j...]\\) where max is over tuples `j...` such
-/// that `segment_ids[j...] == i`.
-///
-/// If the maximum is empty for a given segment ID `i`, it outputs the smallest
-/// possible value for the specific numeric type,
-/// `output[i] = numeric_limits<T>::lowest()`.
-///
-/// If the given segment ID `i` is negative, then the corresponding value is
-/// dropped, and will not be included in the result.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/UnsortedSegmentMax.png" alt>
-/// </div>
-///
-/// For example:
-///
-/// ``` python
-/// c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]])
-/// tf.unsorted_segment_max(c, tf.constant([0, 1, 0]), num_segments=2)
-/// # ==> [[ 4,  3, 3, 4],
-/// #       [5,  6, 7, 8]]
-/// ```
-///
-///
-/// - Parameter segment_ids: A tensor whose shape is a prefix of `data.shape`.
-///
-/// - Output output: Has same shape as data, except for the first `segment_ids.rank`
-///   dimensions, which are replaced with a single dimension which has size
-///   `num_segments`.
-@inlinable
-public static func unsortedSegmentMax<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar,
-    Tnumsegments: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  segmentIds: Tensor<Tindices>,
-  numSegments: Tensor<Tnumsegments>
-) -> Tensor<T> {
-  let op = TFE_Op("UnsortedSegmentMax")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(segmentIds)
-  let _ = op.addInput(numSegments)
-  return op.execute(Int(1))
-}
-
-/// Computes the minimum along segments of a tensor.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
-/// for an explanation of segments.
-///
-/// This operator is similar to the unsorted segment sum operator found
-/// [(here)](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
-/// Instead of computing the sum over segments, it computes the minimum such that:
-///
-/// \\(output_i = \min_{j...} data_[j...]\\) where min is over tuples `j...` such
-/// that `segment_ids[j...] == i`.
-///
-/// If the minimum is empty for a given segment ID `i`, it outputs the largest
-/// possible value for the specific numeric type,
-/// `output[i] = numeric_limits<T>::max()`.
-///
-/// For example:
-///
-/// ``` python
-/// c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]])
-/// tf.unsorted_segment_min(c, tf.constant([0, 1, 0]), num_segments=2)
-/// # ==> [[ 1,  2, 2, 1],
-/// #       [5,  6, 7, 8]]
-/// ```
-///
-/// If the given segment ID `i` is negative, then the corresponding value is
-/// dropped, and will not be included in the result.
-///
-/// - Parameter segment_ids: A tensor whose shape is a prefix of `data.shape`.
-///
-/// - Output output: Has same shape as data, except for the first `segment_ids.rank`
-///   dimensions, which are replaced with a single dimension which has size
-///   `num_segments`.
-@inlinable
-public static func unsortedSegmentMin<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar,
-    Tnumsegments: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  segmentIds: Tensor<Tindices>,
-  numSegments: Tensor<Tnumsegments>
-) -> Tensor<T> {
-  let op = TFE_Op("UnsortedSegmentMin")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(segmentIds)
-  let _ = op.addInput(numSegments)
-  return op.execute(Int(1))
-}
-
-/// Computes the product along segments of a tensor.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
-/// for an explanation of segments.
-///
-/// This operator is similar to the unsorted segment sum operator found
-/// [(here)](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
-/// Instead of computing the sum over segments, it computes the product of all
-/// entries belonging to a segment such that:
-///
-/// \\(output_i = \prod_{j...} data[j...]\\) where the product is over tuples
-/// `j...` such that `segment_ids[j...] == i`.
-///
-/// For example:
-///
-/// ``` python
-/// c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]])
-/// tf.unsorted_segment_prod(c, tf.constant([0, 1, 0]), num_segments=2)
-/// # ==> [[ 4,  6, 6, 4],
-/// #       [5,  6, 7, 8]]
-/// ```
-///
-/// If there is no entry for a given segment ID `i`, it outputs 1.
-///
-/// If the given segment ID `i` is negative, then the corresponding value is
-/// dropped, and will not be included in the result.
-///
-/// - Parameter segment_ids: A tensor whose shape is a prefix of `data.shape`.
-///
-/// - Output output: Has same shape as data, except for the first `segment_ids.rank`
-///   dimensions, which are replaced with a single dimension which has size
-///   `num_segments`.
-@inlinable
-public static func unsortedSegmentProd<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar,
-    Tnumsegments: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  segmentIds: Tensor<Tindices>,
-  numSegments: Tensor<Tnumsegments>
-) -> Tensor<T> {
-  let op = TFE_Op("UnsortedSegmentProd")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(segmentIds)
-  let _ = op.addInput(numSegments)
-  return op.execute(Int(1))
-}
-
-/// Computes the sum along segments of a tensor.
-///
-/// Read
-/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
-/// for an explanation of segments.
-///
-/// Computes a tensor such that
-/// \\(output[i] = \sum_{j...} data[j...]\\) where the sum is over tuples `j...` such
-/// that `segment_ids[j...] == i`.  Unlike `SegmentSum`, `segment_ids`
-/// need not be sorted and need not cover all values in the full
-/// range of valid values.
-///
-/// If the sum is empty for a given segment ID `i`, `output[i] = 0`.
-/// If the given segment ID `i` is negative, the value is dropped and will not be
-/// added to the sum of the segment.
-///
-/// `num_segments` should equal the number of distinct segment IDs.
-///
-/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
-/// <img style="width:100%" src="https://www.tensorflow.org/images/UnsortedSegmentSum.png" alt>
-/// </div>
-///
-/// ``` python
-/// c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]])
-/// tf.unsorted_segment_sum(c, tf.constant([0, 1, 0]), num_segments=2)
-/// # ==> [[ 5,  5, 5, 5],
-/// #       [5,  6, 7, 8]]
-/// ```
-///
-///
-/// - Parameter segment_ids: A tensor whose shape is a prefix of `data.shape`.
-///
-/// - Output output: Has same shape as data, except for the first `segment_ids.rank`
-///   dimensions, which are replaced with a single dimension which has size
-///   `num_segments`.
-@inlinable
-public static func unsortedSegmentSum<
-    T: Numeric & TensorFlowScalar,
-    Tindices: BinaryInteger & TensorFlowScalar,
-    Tnumsegments: BinaryInteger & TensorFlowScalar
->(
-  data: Tensor<T>,
-  segmentIds: Tensor<Tindices>,
-  numSegments: Tensor<Tnumsegments>
-) -> Tensor<T> {
-  let op = TFE_Op("UnsortedSegmentSum")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("Tindices", Tindices.tensorFlowDataType)
-  op.setAttr("Tnumsegments", Tnumsegments.tensorFlowDataType)
-  let _ = op.addInput(data)
-  let _ = op.addInput(segmentIds)
-  let _ = op.addInput(numSegments)
-  return op.execute(Int(1))
-}
-
-/// Op is similar to a lightweight Dequeue.
-///
-/// The basic functionality is similar to dequeue with many fewer
-/// capabilities and options.  This Op is optimized for performance.
-@inlinable
-public static func unstage<Dtypes: TensorGroup>(
-  capacity: Int64 = 0,
-  memoryLimit: Int64 = 0,
-  container: String,
-  sharedName: String
-) -> Dtypes {
-  let op = TFE_Op("Unstage")
-  op.setAttr("capacity", capacity)
-  op.setAttr("memory_limit", memoryLimit)
-  op.setAttr("dtypes", Dtypes._typeList)
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(Dtypes._typeList.count))
-}
-
-@inlinable
-public static func unwrapDatasetVariant(
-  inputHandle: VariantHandle
-) -> VariantHandle {
-  let op = TFE_Op("UnwrapDatasetVariant")
-  let _ = op.addInput(inputHandle)
-  return op.execute(Int(1))
-}
-
-/// Applies upper_bound(sorted_search_values, values) along each row.
-///
-/// Each set of rows with the same index in (sorted_inputs, values) is treated
-/// independently.  The resulting row is the equivalent of calling
-/// `np.searchsorted(sorted_inputs, values, side='right')`.
-///
-/// The result is not a global index to the entire 
-/// `Tensor`, but rather just the index in the last dimension.
-///
-/// A 2-D example:
-///   sorted_sequence = [[0, 3, 9, 9, 10],
-///                      [1, 2, 3, 4, 5]]
-///   values = [[2, 4, 9],
-///             [0, 2, 6]]
-///
-///   result = UpperBound(sorted_sequence, values)
-///
-///   result == [[1, 2, 4],
-///              [0, 2, 5]]
-///
-/// - Parameters:
-///   - sorted_inputs: 2-D Tensor where each row is ordered.
-///   - values: 2-D Tensor with the same numbers of rows as `sorted_search_values`. Contains
-///     the values that will be searched for in `sorted_search_values`.
-///
-/// - Output output: A `Tensor` with the same shape as `values`.  It contains the last scalar index
-///   into the last dimension where values can be inserted without changing the
-///   ordered property.
-@inlinable
-public static func upperBound<
-    T: TensorFlowScalar,
-    OutType: BinaryInteger & TensorFlowScalar
->(
-  sortedInputs: Tensor<T>,
-  _ values: Tensor<T>
-) -> Tensor<OutType> {
-  let op = TFE_Op("UpperBound")
-  op.setAttr("T", T.tensorFlowDataType)
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(sortedInputs)
-  let _ = op.addInput(values)
-  return op.execute(Int(1))
-}
-
-/// Creates a handle to a Variable resource.
-///
-/// - Attrs:
-///   - container: the container this variable is placed in.
-///   - shared_name: the name by which this variable is referred to.
-///   - dtype: the type of this variable. Must agree with the dtypes
-///     of all ops using this variable.
-///   - shape: The (possibly partially specified) shape of this variable.
-@inlinable
-public static func varHandleOp(
-  container: String,
-  sharedName: String,
-  dtype: TensorDataType,
-  shape: TensorShape?
-) -> ResourceHandle {
-  let op = TFE_Op("VarHandleOp")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  op.setAttr("dtype", dtype)
-  op.setAttr("shape", shape)
-  return op.execute(Int(1))
-}
-
-/// Checks whether a resource handle-based variable has been initialized.
-///
-/// - Parameter resource: the input resource handle.
-///
-/// - Output is_initialized: a scalar boolean which is true if the variable has been
-///   initialized.
-@inlinable
-public static func varIsInitializedOp(
-  resource: ResourceHandle
-) -> Tensor<Bool> {
-  let op = TFE_Op("VarIsInitializedOp")
-  let _ = op.addInput(resource)
-  return op.execute(Int(1))
-}
-
-/// Returns the shape of the variable pointed to by `resource`.
-///
-/// This operation returns a 1-D integer tensor representing the shape of `input`.
-///
-/// For example:
-///
-/// ```
-/// # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
-/// shape(t) ==> [2, 2, 3]
-/// ```
-@inlinable
-public static func variableShape<OutType: BinaryInteger & TensorFlowScalar>(
-  _ input: ResourceHandle
-) -> Tensor<OutType> {
-  let op = TFE_Op("VariableShape")
-  op.setAttr("out_type", OutType.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// Returns locations of nonzero / true values in a tensor.
-///
-/// This operation returns the coordinates of true elements in `condition`. The
-/// coordinates are returned in a 2-D tensor where the first dimension (rows)
-/// represents the number of true elements, and the second dimension (columns)
-/// represents the coordinates of the true elements. Keep in mind, the shape of
-/// the output tensor can vary depending on how many true values there are in
-/// `condition`. Indices are output in row-major order.
-///
-/// For example:
-///
-/// ```
-/// # 'input' tensor is [[True, False]
-/// #                    [True, False]]
-/// # 'input' has two true values, so output has two coordinates.
-/// # 'input' has rank of 2, so coordinates have two indices.
-/// where(input) ==> [[0, 0],
-///                   [1, 0]]
-///
-/// # `condition` tensor is [[[True, False]
-/// #                     [True, False]]
-/// #                    [[False, True]
-/// #                     [False, True]]
-/// #                    [[False, False]
-/// #                     [False, True]]]
-/// # 'input' has 5 true values, so output has 5 coordinates.
-/// # 'input' has rank of 3, so coordinates have three indices.
-/// where(input) ==> [[0, 0, 0],
-///                   [0, 1, 0],
-///                   [1, 0, 1],
-///                   [1, 1, 1],
-///                   [2, 1, 1]]
-///
-/// # `condition` tensor is [[[1.5,  0.0]
-/// #                     [-0.5, 0.0]]
-/// #                    [[0.0,  0.25]
-/// #                     [0.0,  0.75]]
-/// #                    [[0.0,  0.0]
-/// #                     [0.0,  0.01]]]
-/// # 'input' has 5 nonzero values, so output has 5 coordinates.
-/// # 'input' has rank of 3, so coordinates have three indices.
-/// where(input) ==> [[0, 0, 0],
-///                   [0, 1, 0],
-///                   [1, 0, 1],
-///                   [1, 1, 1],
-///                   [2, 1, 1]]
-///
-/// # `condition` tensor is [[[1.5 + 0.0j, 0.0  + 0.0j]
-/// #                     [0.0 + 0.5j, 0.0  + 0.0j]]
-/// #                    [[0.0 + 0.0j, 0.25 + 1.5j]
-/// #                     [0.0 + 0.0j, 0.75 + 0.0j]]
-/// #                    [[0.0 + 0.0j, 0.0  + 0.0j]
-/// #                     [0.0 + 0.0j, 0.01 + 0.0j]]]
-/// # 'input' has 5 nonzero magnitude values, so output has 5 coordinates.
-/// # 'input' has rank of 3, so coordinates have three indices.
-/// where(input) ==> [[0, 0, 0],
-///                   [0, 1, 0],
-///                   [1, 0, 1],
-///                   [1, 1, 1],
-///                   [2, 1, 1]]
-/// ```
-@inlinable
-public static func where_<T: TensorFlowScalar>(
-  _ input: Tensor<T>
-) -> Tensor<Int64> {
-  let op = TFE_Op("Where")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(input)
-  return op.execute(Int(1))
-}
-
-/// output = input; While (Cond(output)) { output = Body(output) }
-///
-/// - Parameter input: A list of input tensors whose types are T.
-///
-/// - Attrs:
-///   - T: dtype in use.
-///   - cond:       A function takes 'input' and returns a tensor.  If the tensor is
-///           a scalar of non-boolean, the scalar is converted to a boolean
-///           according to the following rule: if the scalar is a numerical
-///           value, non-zero means True and zero means False; if the scalar is
-///           a string, non-empty means True and empty means False. If the
-///           tensor is not a scalar, non-emptiness means True and False
-///           otherwise.
-///   - body:       A function that takes a list of tensors and returns another
-///           list of tensors. Both lists have the same types as specified
-///           by T.
-///
-/// - Output output: A list of output tensors whose types are T.
-@inlinable
-public static func while_<
-    T: TensorArrayProtocol,
-    CondIn: TensorGroup,
-    CondOut: TensorGroup,
-    BodyIn: TensorGroup,
-    BodyOut: TensorGroup
->(
-  _ input: T,
-  cond: (CondIn) -> CondOut,
-  body: (BodyIn) -> BodyOut,
-  outputShapes: [TensorShape?],
-  parallelIterations: Int64 = 10
-) -> T {
-  let op = TFE_Op("While")
-  op.setAttr("T", input._typeList)
-  op.setAttr("cond", cond)
-  op.setAttr("body", body)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("parallel_iterations", parallelIterations)
-  let _ = op.addInputList(input)
-  return op.execute(Int(input._typeList.count))
-}
-
-/// A Reader that outputs the entire contents of a file as a value.
-///
-/// To use, enqueue filenames in a Queue.  The output of ReaderRead will
-/// be a filename (key) and the contents of that file (value).
-///
-/// - Attrs:
-///   - container: If non-empty, this reader is placed in the given container.
-///     Otherwise, a default container is used.
-///   - shared_name: If non-empty, this reader is named in the given bucket
-///     with this shared_name. Otherwise, the node name is used instead.
-///
-/// - Output reader_handle: The handle to reference the Reader.
-@inlinable
-public static func wholeFileReaderV2(
-  container: String,
-  sharedName: String
-) -> ResourceHandle {
-  let op = TFE_Op("WholeFileReaderV2")
-  op.setAttr("container", container)
-  op.setAttr("shared_name", sharedName)
-  return op.execute(Int(1))
-}
-
-/// A dataset that creates window datasets from the input dataset.
-///
-/// - Parameters:
-///   - size: A scalar representing the number of elements to accumulate in a window.
-///   - shift: A scalar representing the steps moving the sliding window forward in one
-///     iteration. It must be positive.
-///   - stride: A scalar representing the stride of the input elements of the sliding window.
-///     It must be positive.
-///   - drop_remainder: A scalar representing whether a window should be dropped in case its size is
-///     smaller than desired.
-@inlinable
-public static func windowDataset(
-  inputDataset: VariantHandle,
-  size: Tensor<Int64>,
-  shift: Tensor<Int64>,
-  stride: Tensor<Int64>,
-  dropRemainder: Tensor<Bool>,
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("WindowDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  let _ = op.addInput(inputDataset)
-  let _ = op.addInput(size)
-  let _ = op.addInput(shift)
-  let _ = op.addInput(stride)
-  let _ = op.addInput(dropRemainder)
-  return op.execute(Int(1))
-}
-
-/// Worker heartbeat op.
-///
-/// Heartbeats may be sent periodically to indicate the coordinator is still active,
-/// to retrieve the current worker status and to expedite shutdown when necessary.
-///
-/// - Parameter request: A string tensor containing a serialized WorkerHeartbeatRequest
-///
-/// - Output response: A string tensor containing a serialized WorkerHeartbeatResponse
-@inlinable
-public static func workerHeartbeat(
-  request: StringTensor
-) -> StringTensor {
-  let op = TFE_Op("WorkerHeartbeat")
-  let _ = op.addInput(request)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func wrapDatasetVariant(
-  inputHandle: VariantHandle
-) -> VariantHandle {
-  let op = TFE_Op("WrapDatasetVariant")
-  let _ = op.addInput(inputHandle)
-  return op.execute(Int(1))
-}
-
-@inlinable
-public static func writeAudioSummary(
-  writer: ResourceHandle,
-  step: Tensor<Int64>,
-  tag: StringTensor,
-  _ tensor: Tensor<Float>,
-  sampleRate: Tensor<Float>,
-  maxOutputs: Int64 = 3
-) {
-  let op = TFE_Op("WriteAudioSummary")
-  op.setAttr("max_outputs", maxOutputs)
-  let _ = op.addInput(writer)
-  let _ = op.addInput(step)
-  let _ = op.addInput(tag)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(sampleRate)
-  op.execute()
-}
-
-/// Writes contents to the file at input filename. Creates file and recursively
-///
-/// creates directory if not existing.
-///
-/// - Parameters:
-///   - filename: scalar. The name of the file to which we write the contents.
-///   - contents: scalar. The content to be written to the output file.
-@inlinable
-public static func writeFile(
-  filename: StringTensor,
-  contents: StringTensor
-) {
-  let op = TFE_Op("WriteFile")
-  let _ = op.addInput(filename)
-  let _ = op.addInput(contents)
-  op.execute()
-}
-
-@inlinable
-public static func writeGraphSummary(
-  writer: ResourceHandle,
-  step: Tensor<Int64>,
-  _ tensor: StringTensor
-) {
-  let op = TFE_Op("WriteGraphSummary")
-  let _ = op.addInput(writer)
-  let _ = op.addInput(step)
-  let _ = op.addInput(tensor)
-  op.execute()
-}
-
-@inlinable
-public static func writeHistogramSummary<T: Numeric & TensorFlowScalar>(
-  writer: ResourceHandle,
-  step: Tensor<Int64>,
-  tag: StringTensor,
-  _ values: Tensor<T>
-) {
-  let op = TFE_Op("WriteHistogramSummary")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(writer)
-  let _ = op.addInput(step)
-  let _ = op.addInput(tag)
-  let _ = op.addInput(values)
-  op.execute()
-}
-
-@inlinable
-public static func writeImageSummary<T: Numeric & TensorFlowScalar>(
-  writer: ResourceHandle,
-  step: Tensor<Int64>,
-  tag: StringTensor,
-  _ tensor: Tensor<T>,
-  badColor: Tensor<UInt8>,
-  maxImages: Int64 = 3
-) {
-  let op = TFE_Op("WriteImageSummary")
-  op.setAttr("max_images", maxImages)
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(writer)
-  let _ = op.addInput(step)
-  let _ = op.addInput(tag)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(badColor)
-  op.execute()
-}
-
-@inlinable
-public static func writeRawProtoSummary(
-  writer: ResourceHandle,
-  step: Tensor<Int64>,
-  _ tensor: StringTensor
-) {
-  let op = TFE_Op("WriteRawProtoSummary")
-  let _ = op.addInput(writer)
-  let _ = op.addInput(step)
-  let _ = op.addInput(tensor)
-  op.execute()
-}
-
-@inlinable
-public static func writeScalarSummary<T: Numeric & TensorFlowScalar>(
-  writer: ResourceHandle,
-  step: Tensor<Int64>,
-  tag: StringTensor,
-  value: Tensor<T>
-) {
-  let op = TFE_Op("WriteScalarSummary")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(writer)
-  let _ = op.addInput(step)
-  let _ = op.addInput(tag)
-  let _ = op.addInput(value)
-  op.execute()
-}
-
-@inlinable
-public static func writeSummary<T: TensorFlowScalar>(
-  writer: ResourceHandle,
-  step: Tensor<Int64>,
-  _ tensor: Tensor<T>,
-  tag: StringTensor,
-  summaryMetadata: StringTensor
-) {
-  let op = TFE_Op("WriteSummary")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(writer)
-  let _ = op.addInput(step)
-  let _ = op.addInput(tensor)
-  let _ = op.addInput(tag)
-  let _ = op.addInput(summaryMetadata)
-  op.execute()
-}
-
-/// Returns 0 if x == 0, and x / y otherwise, elementwise.
-@inlinable
-public static func xdivy<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Xdivy")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns 0 if x == 0, and x * log(y) otherwise, elementwise.
-@inlinable
-public static func xlogy<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  _ y: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Xlogy")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(y)
-  return op.execute(Int(1))
-}
-
-/// Returns a tensor of zeros with the same shape and type as x.
-///
-/// - Parameter x: a tensor of type T.
-///
-/// - Output y: a tensor of the same shape and type as x but filled with zeros.
-@inlinable
-public static func zerosLike<T: TensorFlowScalar>(
-  _ x: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("ZerosLike")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  return op.execute(Int(1))
-}
-
-/// Compute the Hurwitz zeta function \\(\zeta(x, q)\\).
-///
-/// The Hurwitz zeta function is defined as:
-///
-///
-/// \\(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\\)
-@inlinable
-public static func zeta<T: FloatingPoint & TensorFlowScalar>(
-  _ x: Tensor<T>,
-  q: Tensor<T>
-) -> Tensor<T> {
-  let op = TFE_Op("Zeta")
-  op.setAttr("T", T.tensorFlowDataType)
-  let _ = op.addInput(x)
-  let _ = op.addInput(q)
-  return op.execute(Int(1))
-}
-
-/// Creates a dataset that zips together `input_datasets`.
-@inlinable
-public static func zipDataset(
-  inputDatasets: [VariantHandle],
-  outputTypes: [TensorDataType],
-  outputShapes: [TensorShape?]
-) -> VariantHandle {
-  let op = TFE_Op("ZipDataset")
-  op.setAttr("output_types", outputTypes)
-  op.setAttr("output_shapes", outputShapes)
-  op.setAttr("N", inputDatasets.count)
-  let _ = op.addInputList(inputDatasets)
-  return op.execute(Int(1))
-}
-
-}
diff --git a/Sources/TensorFlow/Bindings/generate_wrappers.py b/Sources/TensorFlow/Bindings/generate_wrappers.py
deleted file mode 100644
index ca52c5d4c..000000000
--- a/Sources/TensorFlow/Bindings/generate_wrappers.py
+++ /dev/null
@@ -1,707 +0,0 @@
-# Copyright 2018 Google LLC
-#
-# 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
-#
-#     https://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.
-
-"""Generates some swift wrapper from some ops description protobuf."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import six
-import tensorflow as tf
-
-from tensorflow.core.framework import types_pb2
-from tensorflow.python.framework import c_api_util
-
-flags = tf.flags
-FLAGS = flags.FLAGS
-
-flags.DEFINE_string(
-  'api_def_path',
-  None,
-  'path to the api_def directory, e.g. tensorflow/core/api_def/base_api')
-
-flags.DEFINE_string(
-  'output_path',
-  None,
-  'path for the generated swift file')
-
-_WARNING = """// !!! THIS CODE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND !!!
-//
-"""
-
-_HEADER = """// Copyright 2018-19 Google LLC
-//
-// 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
-//
-//     https://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.
-
-"""
-
-_OUTPUT_FILE = 'RawOpsGenerated.swift'
-_RENAMED_KEYWORDS = {
-  '': 'empty',
-  'in': 'in_',
-  'var': 'var_',
-  'where': 'where_',
-  'if': 'if_',
-  'for': 'for_',
-  'while': 'while_',
-  'switch': 'switch_',
-  'protocol': 'protocol_',
-  'init': 'init_'}
-
-_TYPE_PROTOCOLS = [
-  (set(), 'TensorFlowScalar'),
-  ({types_pb2.DT_UINT8,
-    types_pb2.DT_UINT16,
-    types_pb2.DT_UINT32,
-    types_pb2.DT_UINT64}, 'UnsignedInteger & TensorFlowScalar'),
-  ({types_pb2.DT_UINT8,
-    types_pb2.DT_UINT16,
-    types_pb2.DT_UINT32,
-    types_pb2.DT_UINT64,
-    types_pb2.DT_INT8,
-    types_pb2.DT_INT16,
-    types_pb2.DT_INT32,
-    types_pb2.DT_INT64}, 'BinaryInteger & TensorFlowScalar'),
-  ({types_pb2.DT_FLOAT,
-    types_pb2.DT_DOUBLE,
-    types_pb2.DT_HALF,
-    types_pb2.DT_BFLOAT16}, 'FloatingPoint & TensorFlowScalar'),
-  ({types_pb2.DT_UINT8,
-    types_pb2.DT_UINT16,
-    types_pb2.DT_UINT32,
-    types_pb2.DT_UINT64,
-    types_pb2.DT_INT8,
-    types_pb2.DT_INT16,
-    types_pb2.DT_INT32,
-    types_pb2.DT_INT64,
-    types_pb2.DT_FLOAT,
-    types_pb2.DT_DOUBLE,
-    types_pb2.DT_HALF,
-    types_pb2.DT_BFLOAT16}, 'Numeric & TensorFlowScalar')]
-
-_SWIFTIFIED_TYPES = {
-  types_pb2.DT_FLOAT: 'Float',
-  types_pb2.DT_DOUBLE: 'Double',
-  types_pb2.DT_INT32: 'Int32',
-  types_pb2.DT_UINT8: 'UInt8',
-  types_pb2.DT_INT16: 'Int16',
-  types_pb2.DT_INT8: 'Int8',
-  types_pb2.DT_INT64: 'Int64',
-  types_pb2.DT_BOOL: 'Bool',
-  types_pb2.DT_UINT16: 'UInt16',
-  types_pb2.DT_UINT32: 'UInt32',
-  types_pb2.DT_UINT64: 'UInt64'}
-
-_SWIFTIFIED_ATTR_TYPES = {
-  'int': 'Int64',
-  'float': 'Double',
-  'bool': 'Bool',
-  'string': 'String',
-  'type': 'TensorDataType',
-  'shape': 'TensorShape?',
-  'list(int)': '[Int32]',
-  'list(float)': '[Double]',
-  'list(bool)': '[Bool]',
-  'list(string)': '[String]',
-  'list(type)': '[TensorDataType]',
-  'list(shape)': '[TensorShape?]'}
-
-_OMITTED_PARAMETER_NAMES = {
-  'x', 'y', 'a', 'b', 'input', 'tensor', 'values'}
-
-_START_COMMENT = '///'
-
-
-class UnableToGenerateCodeError(Exception):
-  def __init__(self, details):
-    self.details = details
-    super(UnableToGenerateCodeError, self).__init__()
-
-  def __str__(self):
-    return self.details
-
-
-class Op(object):
-  def __init__(self, op_def, api_def, enum_store, string_valued=False):
-    self.op_def = op_def
-    self.api_def = api_def
-    self.enum_store = enum_store
-    self.string_valued = string_valued
-    self.inferred_counts = dict()
-
-    # Collect all the input and output arguments.
-    self.input_args = [
-      Argument(arg_def, op=self)
-      for arg_def in self.op_def.input_arg]
-    self.output_args = [
-      Argument(arg_def, op=self)
-      for arg_def in self.op_def.output_arg]
-
-    # Collect all attributes.
-    self.attrs = [
-      Attribute(attr, op=self)
-      for attr in op_def.attr]
-    self.type_attrs = [
-      attr for attr in self.attrs
-      if attr.is_type_attr]
-
-  def swift_function(self):
-    return '''
-{documentation}@inlinable
-public static func {name}{generics}({input_args}
-){return_type} {{
-  {body}
-}}'''.format(
-      documentation=self._swift_documentation(),
-      name=self._swift_name(),
-      generics=self._swift_generics(),
-      input_args=self._swift_input_args(),
-      return_type=self._swift_return_type(),
-      body=self._swift_body())
-
-  def _swift_documentation(self):
-    def comment_block(text, indent_level):
-      """Returns a commented block of text with some specified indentation."""
-      def indent(line_index):
-        if indent_level == 0:
-          return ''
-        if line_index:
-          return '  ' * indent_level
-        return '  ' * (indent_level - 1) + '- '
-
-      return ''.join([
-        (_START_COMMENT + ' ' + indent(line_index) + line + '\n'
-         if line else _START_COMMENT + '\n')
-        for line_index, line in enumerate(text.split('\n'))
-      ])
-
-    def append_list(doc, args, arg_type):
-      """Returns the documentation for lists of inputs/outputs/attributes."""
-      args = [arg for arg in args if arg.description]
-      if len(args) == 1:
-        block = '%s %s: %s' % (arg_type, args[0].name, args[0].description)
-        doc += _START_COMMENT + '\n'
-        doc += comment_block(block, indent_level=1)
-      elif len(args) > 1:
-        doc += '%s\n%s - %ss:\n' % (_START_COMMENT, _START_COMMENT, arg_type)
-        for arg in args:
-          block = '%s: %s' % (arg.name, arg.description)
-          doc += comment_block(block, indent_level=2)
-      return doc
-
-    doc = ''
-    if self.api_def.summary:
-      doc = comment_block(self.api_def.summary, indent_level=0)
-    if self.api_def.description:
-      doc += _START_COMMENT + '\n'
-      doc += comment_block(self.api_def.description, indent_level=0)
-    doc = append_list(doc, self.api_def.in_arg, 'Parameter')
-    doc = append_list(doc, self.api_def.attr, 'Attr')
-    doc = append_list(doc, self.api_def.out_arg, 'Output')
-    if doc and not doc.endswith('\n'):
-      doc = doc + '\n'
-    return doc
-
-  def _swift_name(self):
-    return swift_compatible_identifier(
-      self.op_def.name[0].lower() + self.op_def.name[1:])
-
-  def _swift_generics(self):
-    constraints = [
-      attr.generic_constraints(self.string_valued)
-      for attr in self.attrs]
-    constraints = [c for c in constraints if c is not None]
-    if len(constraints) == 1:
-      return '<' + ', '.join(constraints) + '>'
-    if len(constraints) > 1:
-      return '<\n    ' + ',\n    '.join(constraints) + '\n>'
-    return ''
-
-  def _swift_input_args(self):
-    args = ''
-    for arg in self.input_args:
-      args += '\n  %s: %s,' % (arg.swift_arg_name, str(arg.swift_type(self.string_valued)))
-    for attr in self.attrs:
-      if not attr.is_inferred_type_attr and not attr.is_inferred_number_attr:
-        args += '\n  %s: %s%s,' % (attr.swift_arg_name, attr.swift_type, attr.swift_default)
-    if args != '':
-      args = args[:-1]
-    return args
-
-  def _swift_return_type(self):
-    return_type = ''
-    if len(self.output_args) == 1:
-      return_type = ' -> ' + str(self.output_args[0].swift_type(self.string_valued))
-    elif len(self.output_args) > 1:
-      named_types = [
-        arg.swift_name + ': ' + str(arg.swift_type(self.string_valued))
-        for arg in self.output_args]
-      return_type = ' -> (' + ', '.join(named_types) + ')'
-    return return_type
-
-  def _swift_body(self):
-    body = 'let op = TFE_Op("{}")\n  '.format(self.op_def.name)
-    setters = []
-    for attr in self.attrs:
-      setters.append(attr.swift_setter(self.string_valued))
-    for arg in self.input_args:
-      setters.append(arg.swift_setter())
-    body += '\n  '.join(setters)
-    counts = ['Int({})'.format(arg.swift_count) for arg in self.output_args]
-    if len(self.output_args) == 0:
-      return body + '\n  op.execute()'
-    body += '\n  return op.execute({})'.format(', '.join(counts))
-    return body
-
-
-class Argument(object):
-  def __init__(self, arg_def, op):
-    self.arg_def = arg_def
-    self.op = op
-    self.is_list = arg_def.number_attr is not '' \
-                   or arg_def.type_list_attr is not ''
-
-  @property
-  def name(self):
-    return self.arg_def.name
-
-  @property
-  def swift_name(self):
-    return swift_compatible_identifier(
-      self.name[0].lower() + self.name[1:])
-
-  @property
-  def swift_arg_name(self):
-    name = self.swift_name
-    if name in _OMITTED_PARAMETER_NAMES:
-      name = '_ ' + name
-    return name
-
-  def swift_type(self, string_valued=False):
-    return self.type.swift_type(
-      string_valued=self.allows_string and string_valued)
-
-  def swift_setter(self):
-    if self.is_list:
-      return 'let _ = op.addInputList({})'.format(self.swift_name)
-    else:
-      return 'let _ = op.addInput({})'.format(self.swift_name)
-
-  @property
-  def swift_count(self):
-    number_attr = self.arg_def.number_attr
-    if number_attr and number_attr in self.op.inferred_counts:
-      return self.op.inferred_counts[number_attr]
-    if self.arg_def.type_list_attr:
-      return self.op.inferred_counts[self.arg_def.type_list_attr]
-    return '1'
-
-  @property
-  def type(self):
-    number = self.arg_def.number_attr
-    if self.arg_def.type_attr:
-      type_attr = next(
-        attr for attr in self.op.type_attrs
-        if attr.name == self.arg_def.type_attr)
-      return Type('Tensor', base_type=type_attr.swift_name, number=number)
-    if self.arg_def.type_list_attr:
-      type_attr = next(
-        attr for attr in self.op.type_attrs
-        if attr.name == self.arg_def.type_list_attr)
-      # There are never any numbered type lists.
-      return Type(type_attr.swift_name)
-    if self.arg_def.type in _SWIFTIFIED_TYPES:
-      base_type = _SWIFTIFIED_TYPES[self.arg_def.type]
-      return Type('Tensor', base_type=base_type, number=number)
-    if self.arg_def.type == types_pb2.DT_STRING:
-      return Type('Tensor', base_type='String', number=number)
-    if self.arg_def.type == types_pb2.DT_RESOURCE:
-      return Type('ResourceHandle', number=number)
-    if self.arg_def.type == types_pb2.DT_VARIANT:
-      return Type('VariantHandle', number=number)
-    raise UnableToGenerateCodeError(
-      'Unsupported type for argument "%s".' % self.name)
-
-  @property
-  def allows_string(self):
-    if self.arg_def.type_attr:
-      type_attr = next(
-        attr for attr in self.op.type_attrs
-        if attr.name == self.arg_def.type_attr)
-      return types_pb2.DT_STRING in type_attr.attr_def.allowed_values.list.type
-    return False
-
-
-class Type(object):
-  def __init__(self, kind, base_type=None, number=None):
-    self.kind = kind
-    self.base_type = base_type
-    self.number = number
-
-  @property
-  def count(self):
-    return self.number if self.number else 1
-
-  def swift_type(self, string_valued=False):
-    if self.kind == 'Tensor':
-      if self.base_type == 'String' or string_valued:
-        name = 'StringTensor'
-      else:
-        name = 'Tensor<' + self.base_type + '>'
-    elif self.kind == 'TensorHandle':
-      name = 'TensorHandle<' + self.base_type + '>'
-    elif self.kind == 'ResourceHandle':
-      name = 'ResourceHandle'
-    elif self.kind == 'VariantHandle':
-      name = 'VariantHandle'
-    else:
-      name = self.kind
-    return ('[%s]' % name) if self.number else name
-
-
-class Attribute(object):
-  """Represents information extracted from op `type` and `list(type)` attributes."""
-
-  def __init__(self, attr_def, op):
-    self.attr_def = attr_def
-    self.op = op
-    self.is_type_attr = attr_def.type in ['type', 'list(type)']
-
-    # Check whether the value of this attribute can be
-    # inferred automatically (this only applies to
-    # type-valued attributes).
-    input_args = list(op.op_def.input_arg)
-    output_args = list(op.op_def.output_arg)
-    input_arg_type_attrs = set(
-      [arg.type_attr for arg in input_args] +
-      [arg.type_list_attr for arg in input_args])
-    output_arg_type_attrs = set(
-      [arg.type_attr for arg in output_args] +
-      [arg.type_list_attr for arg in output_args])
-    arg_type_attrs = input_arg_type_attrs.union(output_arg_type_attrs)
-    self.is_inferred_type_attr = attr_def.name in arg_type_attrs
-    self.is_output_type_attr = attr_def.name in output_arg_type_attrs
-    self.is_func_attr = self.attr_def.type == 'func'
-
-    # We use this for obtaining the `_typeList` property.
-    self.input_arg = None
-    self.is_inferred_number_attr = False
-    for arg in self.op.input_args:
-      if self.attr_def.name in [arg.arg_def.type_attr,
-                                arg.arg_def.type_list_attr] or \
-         self.attr_def.name == arg.arg_def.number_attr:
-        self.input_arg = arg
-        self.is_inferred_number_attr = True
-        break
-
-    # The following properties are only relevant for
-    # non-inferred-type-valued attributes.
-    self._swift_type = ''
-    self._use_enum = False
-    if not self.is_inferred_type_attr and not self.is_func_attr:
-      if self.attr_def.type not in _SWIFTIFIED_ATTR_TYPES:
-        raise UnableToGenerateCodeError(
-          'Unsupported type for attribute "%s".'
-          % self.attr_def.name)
-
-      # Get the arg type.
-      self._swift_type = _SWIFTIFIED_ATTR_TYPES[self.attr_def.type]
-
-      # Check if the arg is an enum type.
-      self._use_enum = False
-      if self.attr_def.type == 'string':
-        allowed_values = tuple(sorted(self.attr_def.allowed_values.list.s))
-        if allowed_values:
-          self._swift_type = self.op.enum_store.maybe_add(
-            allowed_values, self.attr_def.name)
-          self._use_enum = True
-    if self.is_func_attr:
-      input_type = self.swift_name.capitalize() + 'In'
-      output_type = self.swift_name.capitalize() + 'Out'
-      self._swift_type = '({}) -> {}'.format(input_type, output_type)
-
-  @property
-  def name(self):
-    return self.attr_def.name
-
-  @property
-  def swift_name(self):
-    if self.is_inferred_type_attr:
-      return swift_compatible_identifier(
-        self.name, capitalize=True)
-    return swift_compatible_identifier(
-      self.name[0].lower() + self.name[1:])
-
-  @property
-  def swift_arg_name(self):
-    name = self.swift_name
-    if name in _OMITTED_PARAMETER_NAMES:
-      name = '_ ' + name
-    return name
-
-  @property
-  def swift_type(self):
-    return self._swift_type
-
-  @property
-  def swift_default(self):
-    def swift_float(f):
-      if f == float('inf'): return 'Double.infinity'
-      if f == float('-inf'): return '-Double.infinity'
-      return '%g' % f
-
-    if not self.is_inferred_type_attr and self.attr_def.default_value:
-      default_value = self.attr_def.default_value
-      if default_value.HasField('b'):
-        default_value = str(default_value.b).lower()
-      elif default_value.HasField('i'):
-        default_value = str(default_value.i)
-      elif default_value.HasField('f'):
-        default_value = swift_float(default_value.f)
-      elif default_value.HasField('s') and default_value.s:
-        s = str(default_value.s, encoding='utf-8')
-        default_value = '.' + swift_compatible_identifier(s.lower()) \
-          if self._use_enum else '"' + s + '"'
-      elif default_value.HasField('list'):
-        if default_value.list.i:
-          default_values = [str(s) for s in default_value.list.i]
-          default_value = '[' + ', '.join(default_values) + ']'
-        elif default_value.list.f:
-          default_values = [swift_float(s) for s in default_value.list.f]
-          default_value = '[' + ', '.join(default_values) + ']'
-        else:
-          default_value = None
-      else:
-        default_value = None
-      if default_value is not None:
-        default_value = default_value.replace("\t", "\\t")
-        return ' = ' + default_value
-    return ''
-
-  def swift_setter(self, string_valued=False):
-    # Inferred-type-valued attributes.
-    if self.is_inferred_type_attr:
-      name = self.swift_name
-      if self.input_arg is not None:
-        name = self.input_arg.swift_name
-      if self.attr_def.type == 'list(type)' or self.is_inferred_number_attr:
-        self.op.inferred_counts[self.name] = name + '._typeList.count'
-      if self.attr_def.type == 'list(type)':
-        return 'op.setAttr("{}", {}._typeList)'.format(self.name, name)
-      if string_valued and self.allows_string:
-        return 'op.setAttr("{}", TensorDataType(TF_STRING))'.format(self.name)
-      return 'op.setAttr("{}", {}.tensorFlowDataType)'.format(self.name, self.swift_name)
-
-    if self.is_inferred_number_attr:
-      # The following is used for inferring the lengths of output lists.
-      self.op.inferred_counts[self.name] = self.input_arg.swift_name + '.count'
-      return 'op.setAttr("{}", {}.count)'.format(self.name, self.input_arg.swift_name)
-    
-    if self.attr_def.type == 'int':
-      # The following is used for inferring the lengths of output lists.
-      self.op.inferred_counts[self.name] = self.swift_name
-
-    # Remaining attributes.
-    value = self.swift_name + '.cName' if self._use_enum else self.swift_name
-    return 'op.setAttr("{}", {})'.format(self.name, value)
-
-  def generic_constraints(self, string_valued):
-    # We use this for obtaining the `_typeList` property.
-    input_arg = None
-    if self.attr_def.type == 'list(type)':
-      for arg in self.op.input_args:
-        if self.attr_def.name in [arg.arg_def.type_attr,
-                                  arg.arg_def.type_list_attr]:
-          input_arg = arg
-          break
-    if self.is_func_attr:
-      input_type = self.swift_name.capitalize() + 'In'
-      output_type = self.swift_name.capitalize() + 'Out'
-      return '{}: TensorGroup,\n    {}: TensorGroup'.format(
-        input_type, output_type)
-    if not self.is_inferred_type_attr:
-      return None
-    protocol = None
-    if self.attr_def.type == 'list(type)' and input_arg is None:
-      protocol = 'TensorGroup'
-    elif self.attr_def.type == 'list(type)':
-      protocol = 'TensorArrayProtocol'
-    elif self.attr_def.type == 'type':
-      if string_valued and self.allows_string:
-        return None
-      protocol = 'TensorFlowScalar'
-      allowed_types = set(self.attr_def.allowed_values.list.type)
-      allowed_types &= set(_SWIFTIFIED_TYPES.keys())
-      for types, protocol_name in _TYPE_PROTOCOLS:
-        if allowed_types.issubset(types):
-          protocol = protocol_name
-          break
-    if protocol is not None:
-      return self.swift_name + ': ' + protocol
-    return None
-
-  @property
-  def allows_string(self):
-    return types_pb2.DT_STRING in self.attr_def.allowed_values.list.type
-
-
-def swift_compatible_identifier(s, capitalize=False):
-  """Transforms an identifier to be more swift idiomatic."""
-  if s in _RENAMED_KEYWORDS:
-    return _RENAMED_KEYWORDS[s]
-  if capitalize:
-    s = s.capitalize()
-  without_underscores = []
-  capitalize_next_char = False
-  for c in s:
-    if c == '-' or c == '_' or c == '(' or c == ')':
-      capitalize_next_char = True
-    elif capitalize_next_char:
-      capitalize_next_char = False
-      without_underscores.append(c.upper())
-    else:
-      without_underscores.append(c)
-  return ''.join(without_underscores)
-
-
-class EnumStore(object):
-  """Stores details on string attributes represented as swift enums."""
-
-  def __init__(self):
-    self._entries = {}
-    self._type_names = set()
-    self._counter = 1
-
-  def enum_codes(self):
-    """Generates the swift code for enums."""
-    codes = []
-    entries = list(six.iteritems(self._entries))
-    for allowed_values, type_name in sorted(entries, key=lambda x: x[1]):
-      allowed_values = [str(a, encoding='utf-8') for a in allowed_values]
-      codes.append(
-          # FIXME: Re-add `@_frozen` after SR-9739 is resolved.
-          # https://bugs.swift.org/browse/SR-9739
-          # '@_frozen\n' +
-          '// @_frozen // SR-9739\n' +
-          'public enum {} {{\n'.format(type_name) +
-          '\n'.join(['  case {}'.format(
-            swift_compatible_identifier(a.lower()))
-            for a in allowed_values]) +
-          '\n\n' +
-          '  @inlinable\n' +
-          '  var cName: String {\n' +
-          '    get {\n' +
-          '      switch self {\n' +
-          '\n'.join(['      case .{}: return "{}"'.format(
-            swift_compatible_identifier(a.lower()), a)
-            for a in allowed_values]) +
-          '\n' +
-          '      }\n' +
-          '    }\n' +
-          '  }\n' +
-          '}')
-    return codes
-
-  def maybe_add(self, allowed_values, attr_def_name):
-    if allowed_values in self._entries:
-      return self._entries[allowed_values]
-    type_name = swift_compatible_identifier(attr_def_name, capitalize=True)
-    while type_name in self._type_names:
-      type_name += str(self._counter)
-      self._counter += 1
-    self._type_names.add(type_name)
-    self._entries[allowed_values] = type_name
-    return type_name
-
-
-def main(argv):
-  del argv  # Unused.
-  if FLAGS.output_path is None:
-    raise ValueError('No output_path has been set')
-
-  api_def_map = c_api_util.ApiDefMap()
-
-  op_codes = []
-  enum_store = EnumStore()
-  op_names = api_def_map.op_names()
-  if FLAGS.api_def_path is not None:
-    for op_name in op_names:
-      path = os.path.join(FLAGS.api_def_path, 'api_def_%s.pbtxt' % op_name)
-      if not tf.gfile.Exists(path):
-        continue
-      with tf.gfile.Open(path, 'r') as fobj:
-        data = fobj.read()
-      try:
-        api_def_map.put_api_def(data)
-      except Exception as e:
-        print('Cannot load api def for %s: %s' % (op_name, str(e)))
-
-  num_generated = 0
-  for op_name in sorted(op_names):
-    try:
-      if op_name[0] == '_': continue
-      op_def = api_def_map.get_op_def(op_name)
-      if any(a.is_ref for a in op_def.input_arg):
-        raise UnableToGenerateCodeError('has ref-valued input')
-      if any(a.is_ref for a in op_def.output_arg):
-        raise UnableToGenerateCodeError('has ref-valued output')
-      api_def = api_def_map.get_api_def(bytes(op_name, 'utf8'))
-
-      # It would be nicer to handle `StringTensor` in a more
-      # general way by having `String` conform to `TensorFlowScalar`.
-      default_op = Op(op_def, api_def, enum_store, string_valued=False)
-      string_valued_op = Op(op_def, api_def, enum_store, string_valued=True)
-      default_code = default_op.swift_function()
-      string_valued_code = string_valued_op.swift_function()
-      op_codes.append(default_code)
-      if string_valued_code != default_code:
-        op_codes.append(string_valued_code)
-      num_generated += 1
-    except UnableToGenerateCodeError as e:
-      print('Cannot generate code for %s: %s' % (op_name, e.details))
-  print('Generated code for %d/%d ops.' % (num_generated, len(op_names)))
-
-  version_codes = [
-      'static let generatedTensorFlowVersion = "%s"' % tf.__version__,
-      'static let generatedTensorFlowGitVersion = "%s"' % tf.__git_version__]
-
-  swift_code = (
-      _WARNING +
-      _HEADER +
-      'import CTensorFlow\n\n' +
-      '\npublic enum Raw {\n\n' +
-      '\n'.join(version_codes) +
-      '\n\n' +
-      '\n\n'.join(enum_store.enum_codes()) +
-      '\n\n' +
-      '\n'.join(op_codes) +
-      '\n\n}\n')
-  with tf.gfile.Open(FLAGS.output_path, 'w') as f:
-    f.write(swift_code)
-
-
-if __name__ == '__main__':
-  tf.app.run(main)
diff --git a/clone_tensorflow_bindings.sh b/clone_tensorflow_bindings.sh
new file mode 100755
index 000000000..625a2a2c6
--- /dev/null
+++ b/clone_tensorflow_bindings.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+git clone git@github.com:tensorflow/swift-bindings.git Sources/TensorFlow/Bindings

From fd1c7662bb69e9286338ab9c71eb05298be25a6e Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Fri, 17 May 2019 18:04:01 -0400
Subject: [PATCH 32/55] Merged upstream changes.

---
 Sources/TensorFlow/Core/DataTypes.swift       |   1 -
 .../Core/DifferentialOperators.swift          |  32 +-
 Sources/TensorFlow/Core/Runtime.swift         | 433 ++----------------
 Sources/TensorFlow/Core/Tensor.swift          |   8 -
 Sources/TensorFlow/Operators/Basic.swift      |   6 +-
 5 files changed, 49 insertions(+), 431 deletions(-)

diff --git a/Sources/TensorFlow/Core/DataTypes.swift b/Sources/TensorFlow/Core/DataTypes.swift
index 88ff668c7..622db5f7a 100644
--- a/Sources/TensorFlow/Core/DataTypes.swift
+++ b/Sources/TensorFlow/Core/DataTypes.swift
@@ -77,7 +77,6 @@ public typealias TensorFlowInteger = TensorFlowScalar & BinaryInteger
 public protocol TensorFlowFloatingPoint: TensorFlowScalar & BinaryFloatingPoint & Differentiable
     where Self.RawSignificand: FixedWidthInteger,
           Self == Self.TangentVector,
-          Self == Self.CotangentVector,
           Self == Self.AllDifferentiableVariables {}
 
 extension Float: TensorFlowFloatingPoint {}
diff --git a/Sources/TensorFlow/Core/DifferentialOperators.swift b/Sources/TensorFlow/Core/DifferentialOperators.swift
index c576478b5..1092c2cea 100644
--- a/Sources/TensorFlow/Core/DifferentialOperators.swift
+++ b/Sources/TensorFlow/Core/DifferentialOperators.swift
@@ -20,14 +20,14 @@ public extension Differentiable {
     @inlinable
     func gradient<R: TensorFlowFloatingPoint>(
         in f: @differentiable (Self) -> Tensor<R>
-    ) -> CotangentVector {
+    ) -> TangentVector {
         return self.pullback(in: f)(Tensor<R>(1))
     }
 
     @inlinable
     func valueWithGradient<R: TensorFlowFloatingPoint>(
         in f: @differentiable (Self) -> Tensor<R>
-    ) -> (value: Tensor<R>, gradient: CotangentVector) {
+    ) -> (value: Tensor<R>, gradient: TangentVector) {
         let (y, pb) = self.valueWithPullback(in: f)
         return (y, pb(Tensor<R>(1)))
     }
@@ -36,7 +36,7 @@ public extension Differentiable {
     func gradient<T: Differentiable, R: TensorFlowFloatingPoint>(
         at x: T,
         in f: @differentiable (Self, T) -> Tensor<R>
-    ) -> (CotangentVector, T.CotangentVector) {
+    ) -> (TangentVector, T.TangentVector) {
         return self.pullback(at: x, in: f)(Tensor<R>(1))
     }
 
@@ -44,7 +44,7 @@ public extension Differentiable {
     func valueWithGradient<T: Differentiable, R: TensorFlowFloatingPoint>(
         at x: T,
         in f: @differentiable (Self, T) -> Tensor<R>
-    ) -> (value: Tensor<R>, gradient: (CotangentVector, T.CotangentVector)) {
+    ) -> (value: Tensor<R>, gradient: (TangentVector, T.TangentVector)) {
         let (y, pb) = self.valueWithPullback(at: x, in: f)
         return (y, pb(Tensor<R>(1)))
     }
@@ -60,7 +60,7 @@ public extension Differentiable {
 public func valueWithGradient<T, R>(
     at x: T,
     in f: @differentiable (T) -> Tensor<R>
-) -> (value: Tensor<R>, gradient: T.CotangentVector)
+) -> (value: Tensor<R>, gradient: T.TangentVector)
 where T: Differentiable, R: TensorFlowFloatingPoint {
     let (y, pullback) = valueWithPullback(at: x, in: f)
     return (y, pullback(Tensor<R>(1)))
@@ -71,7 +71,7 @@ public func valueWithGradient<T, U, R>(
     at x: T,
     _ y: U,
     in f: @differentiable (T, U) -> Tensor<R>
-) -> (value: Tensor<R>, gradient: (T.CotangentVector, U.CotangentVector))
+) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector))
     where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint {
     let (y, pullback) = valueWithPullback(at: x, y, in: f)
     return (y, pullback(Tensor<R>(1)))
@@ -83,7 +83,7 @@ public func valueWithGradient<T, U, R>(
 //     _ y: U,
 //     _ z: V,
 //     in f: @differentiable (T, U, V) -> Tensor<R>
-// ) -> (value: Tensor<R>, gradient: (T.CotangentVector, U.CotangentVector, V.CotangentVector))
+// ) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector, V.TangentVector))
 //   where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint {
 //   let (y, pullback) = valueWithPullback(at: x, y, z, in: f)
 //   return (y, pullback(Tensor<R>(1)))
@@ -94,7 +94,7 @@ public func valueWithGradient<T, U, R>(
 @inlinable
 public func valueWithGradient<T, R>(
     of f: @escaping @differentiable (T) -> Tensor<R>
-) -> (T) -> (value: Tensor<R>, gradient: T.CotangentVector)
+) -> (T) -> (value: Tensor<R>, gradient: T.TangentVector)
     where T: Differentiable, R: TensorFlowFloatingPoint {
     return { x in valueWithGradient(at: x, in: f) }
 }
@@ -102,7 +102,7 @@ public func valueWithGradient<T, R>(
 @inlinable
 public func valueWithGradient<T, U, R>(
     of f: @escaping @differentiable (T, U) -> Tensor<R>
-) -> (T, U) -> (value: Tensor<R>, gradient: (T.CotangentVector, U.CotangentVector))
+) -> (T, U) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector))
   where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint {
   return { x, y in valueWithGradient(at: x, y, in: f) }
 }
@@ -112,7 +112,7 @@ public func valueWithGradient<T, U, R>(
 //     of f: @escaping @differentiable (T, U, V) -> Tensor<R>
 // ) -> (T, U, V) -> (
 //     value: Tensor<R>,
-//     gradient: (T.CotangentVector, U.CotangentVector, V.CotangentVector))
+//     gradient: (T.TangentVector, U.TangentVector, V.TangentVector))
 //     where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint {
 //   return { x, y, z in valueWithGradient(at: x, y, z, in: f) }
 // }
@@ -123,7 +123,7 @@ public func valueWithGradient<T, U, R>(
 public func gradient<T, R>(
     at x: T,
     in f: @differentiable (T) -> Tensor<R>
-) -> T.CotangentVector where T: Differentiable, R: TensorFlowFloatingPoint {
+) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint {
     return pullback(at: x, in: f)(Tensor<R>(1))
 }
 
@@ -132,7 +132,7 @@ public func gradient<T, U, R>(
     at x: T,
     _ y: U,
     in f: @differentiable (T, U) -> Tensor<R>
-) -> (T.CotangentVector, U.CotangentVector)
+) -> (T.TangentVector, U.TangentVector)
     where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint {
     return pullback(at: x, y, in: f)(Tensor<R>(1))
 }
@@ -143,7 +143,7 @@ public func gradient<T, U, R>(
 //     _ y: U,
 //     _ z: V,
 //     in f: @differentiable (T, U, V) -> Tensor<R>
-// ) -> (T.CotangentVector, U.CotangentVector, V.CotangentVector)
+// ) -> (T.TangentVector, U.TangentVector, V.TangentVector)
 //     where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint {
 //     return pullback(at: x, y, z, in: f)(Tensor<R>(1))
 // }
@@ -153,14 +153,14 @@ public func gradient<T, U, R>(
 @inlinable
 public func gradient<T, R>(
     of f: @escaping @differentiable (T) -> Tensor<R>
-) -> (T) -> T.CotangentVector where T: Differentiable, R: TensorFlowFloatingPoint {
+) -> (T) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint {
     return { x in gradient(at: x, in: f) }
 }
 
 @inlinable
 public func gradient<T, U, R>(
     of f: @escaping @differentiable (T, U) -> Tensor<R>
-) -> (T, U) -> (T.CotangentVector, U.CotangentVector)
+) -> (T, U) -> (T.TangentVector, U.TangentVector)
     where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint {
     return { x, y in gradient(at: x, y, in: f) }
 }
@@ -168,7 +168,7 @@ public func gradient<T, U, R>(
 // @inlinable
 // public func gradient<T, U, V, R>(
 //     of f: @escaping @differentiable (T, U, V) -> Tensor<R>
-// ) -> (T, U, V) -> (T.CotangentVector, U.CotangentVector, V.CotangentVector)
+// ) -> (T, U, V) -> (T.TangentVector, U.TangentVector, V.TangentVector)
 //     where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint {
 //     return { x, y, z in gradient(at: x, y, z, in: f) }
 // }
diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index ba01536f4..a3467b52b 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -453,12 +453,6 @@ public enum _RuntimeConfig {
   /// tensor program in this process.
   static public var tensorFlowRuntimeInitialized = false
 
-  /// When true, run the entire tensor computation in
-  /// _TFCStartTensorComputation(), instead of running it on a separate thread.
-  /// - Note: Set to true only for debugging purposes, as it has limited
-  ///   functionality (e.g. no sends/recvs support).
-  static public var usesSynchronousExecution = false
-
   /// For CPU and GPU execution without XLA, use the auto mode. For XLA and/or
   /// TPU execution, set the enum value accordingly.
   static public var executionMode: _ExecutionMode = .auto
@@ -526,12 +520,6 @@ private func configureRuntimeFromEnvironment() {
       debugLog("Setting TPU execution with infeed from env.")
   }
 
-  if let value = getenv("SWIFT_TENSORFLOW_SYNC_EXECUTION"),
-    String(cString: value).lowercased() == "true" {
-      _RuntimeConfig.usesSynchronousExecution = true
-      debugLog("Using sync execution from env.")
-  }
-
   if let value = getenv("SWIFT_TENSORFLOW_SERVER_ADDRESS") {
     let address = String(cString: value)
     debugLog("Env var SWIFT_TENSORFLOW_SERVER_ADDRESS has value \(address).")
@@ -1353,12 +1341,7 @@ public final class _TensorComputation {
   /// mode, we use a single thread (that's sufficient as these N device
   /// functions can be sent to the same TF_SessionRun() call.)
   ///
-  /// The global config flag '_RuntimeConfig.usesSynchronousExecution' decides
-  /// whether tensor computation should be synchronous: if true, this property
-  /// will always be empty. Otherwise, this property is non-empty only when the
-  /// tensor computation is on-going.
-  /// TODO: Remove the `usesSynchronousExecution` mode as it is very limiting
-  /// (e.g. does not support running multiple device functions).
+  /// This property is non-empty only when the tensor computation is on-going.
   private var pthreads: [pthread_t] = []
 
   /// The data structure to pass into pthread creation API.
@@ -1442,51 +1425,43 @@ public final class _TensorComputation {
     debugLog("Starting TF graph execution.")
 
     // If it's asynchronous, we execute the tensor computation via threads.
-    if !_RuntimeConfig.usesSynchronousExecution {
-      let threadCount = helperFunctionCount + 1
-      for threadIndex in 0..<threadCount {
-        // The function to launch in the parallel thread.
+    let threadCount = helperFunctionCount + 1
+	  for threadIndex in 0..<threadCount {
+	    // The function to launch in the parallel thread.
 #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
-        typealias ThreadBody = @convention(c)
-          (UnsafeMutableRawPointer) -> UnsafeMutableRawPointer?
+      typealias ThreadBody = @convention(c)
+        (UnsafeMutableRawPointer) -> UnsafeMutableRawPointer?
 #else
-        typealias ThreadBody = @convention(c)
-          (UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer?
+      typealias ThreadBody = @convention(c)
+        (UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer?
 #endif
-        let body: ThreadBody = { arg in
-          // Set the cancelability of the detached thread.
-          pthread_setcanceltype(Int32(PTHREAD_CANCEL_DEFERRED), nil)
-          // Execute the tensor computation.
+      let body: ThreadBody = { arg in
+        // Set the cancelability of the detached thread.
+        pthread_setcanceltype(Int32(PTHREAD_CANCEL_DEFERRED), nil)
+        // Execute the tensor computation.
 #if !(os(macOS) || os(iOS) || os(watchOS) || os(tvOS))
-          let arg = arg!
+        let arg = arg!
 #endif
-          let param: ThreadParam =
-            Unmanaged.fromOpaque(arg).takeRetainedValue()
-          param.computation.execute(threadIndex: param.threadIndex)
-          checkOk(param.computation.status)
-          return nil
-        }
+        let param: ThreadParam =
+          Unmanaged.fromOpaque(arg).takeRetainedValue()
+        param.computation.execute(threadIndex: param.threadIndex)
+        checkOk(param.computation.status)
+        return nil
+      }
 #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
-        var newThread: pthread_t!
+      var newThread: pthread_t!
 #else
-        var newThread = pthread_t()
+      var newThread = pthread_t()
 #endif
         let creationStatus = pthread_create(
-          &newThread, nil, body,
-          Unmanaged.passRetained(
-            ThreadParam(computation: self,
-                        threadIndex: threadIndex)).toOpaque()
-        )
-        // TODO(hongm): do error handling.
-        internalConsistencyCheck(creationStatus == 0)
-        pthreads.append(newThread)
-      }
-    }
-    // If it's synchronous, we call execute() on the main thread directly.
-    else {
-      // Log a debug message to differentiate from async computation.
-      debugLog("Running tensor computation synchronously.")
-      execute(threadIndex: 0)
+	        &newThread, nil, body,
+	        Unmanaged.passRetained(
+	          ThreadParam(computation: self,
+	                      threadIndex: threadIndex)).toOpaque()
+	      )
+	      // TODO(hongm): do error handling.
+	      internalConsistencyCheck(creationStatus == 0)
+	      pthreads.append(newThread)
     }
     debugLog("Exiting _TensorComputation.init().")
   }
@@ -1543,8 +1518,7 @@ internal extension _TensorComputation {
   func finish() -> [CTensorHandle] {
     debugLog("Calling _TensorComputation.finish().")
     if pthreads.isEmpty {
-      internalConsistencyCheck(
-        _RuntimeConfig.usesSynchronousExecution, """
+      fatalError("""
           finish() is called in async execution mode with pthread == nil -- \
           Was finish() already called?
           """)
@@ -1585,138 +1559,6 @@ internal func _TFCEagerExecute(_ op: CTFEOp,
   }
 }
 
-//===----------------------------------------------------------------------===//
-// - MARK: Compiler runtime entrypoints
-//===----------------------------------------------------------------------===//
-// These are the entrypoints that are well-known to the compiler internals.  The
-// signatures and forms must not be changed without updating the compiler.  Any
-// code put into the body of these functions will end up being inlined into the
-// user code, so they are generally just wrappers around the implementation
-// above.
-
-/// Loads the TF computation from a binary TF FunctionDef proto given by 'bytes'
-/// and 'size', start the computation, and return a _TensorComputation object as
-/// a unique identifier for that computation.
-///
-/// - Parameters:
-///   - programByteAddress: The address of the raw program.
-///   - programByteCount: The number of bytes in the program.
-///   - entryFunctionBaseNameAddress: The base name of the functions to run.
-///   - tensorArgumentAddress: The address to the buffer containing tensor
-///     arguments as CTensorHandle.
-///   - tensorArgumentCount: The number of tensor arguments to pass in.
-///   - helperFunctionCount: The number of helper functions to run.
-///   - resultCount: The number of output tensors.
-@usableFromInline
-@_silgen_name("_swift_tfc_StartTensorComputation")
-internal func _TFCStartTensorComputation(
-  _ programByteAddress: UnsafeRawPointer,
-  _ programByteCount: Int,
-  _ entryFunctionBaseNameAddress: UnsafePointer<Int8>,
-  _ tensorArgumentAddress: UnsafePointer<CTensorHandle>,
-  _ tensorArgumentCount: Int,
-  _ helperFunctionCount: Int,
-  _ resultCount: Int
-) -> _TensorComputation {
-
-  debugLog("""
-    _TFCStartTensorComputation() is called with \(programByteCount) \
-    program bytes, \(tensorArgumentCount) input tensors \
-    \(String(cString:entryFunctionBaseNameAddress)) as the func base name, \
-    \(helperFunctionCount) helper functions, and \(resultCount) output tensors.
-    """)
-
-  internalConsistencyCheck(programByteCount > 0, "Cannot run an empty graph!")
-
-  return _TensorComputation(programByteAddress: programByteAddress,
-                            programByteCount: programByteCount,
-                            entryFunctionBaseNameAddress: entryFunctionBaseNameAddress,
-                            tensorArgumentAddress: tensorArgumentAddress,
-                            tensorArgumentCount: tensorArgumentCount,
-                            helperFunctionCount: helperFunctionCount,
-                            resultCount: resultCount)
-}
-
-/// Waits for completion of the computation as given by `computation`, and
-/// returns results.
-/// Aborts the process on error, and emits an error string to STDERR.
-///
-/// - Parameters:
-///   - computation: The tensor computation to finish.
-///   - tensorResultAddress: The address to an uninitialized buffer to accept
-///     results of the computation, where the output tensors may live on CPU or
-///     GPU.
-///   - tensorResultCount: The number of results to accept from the computation.
-/// - Note: The result address as passed in is pointing to uninitialized memory,
-///   this must initialize the memory, transferring ownership of the tensor
-///   handles to the caller.
-@usableFromInline
-@_silgen_name("_swift_tfc_FinishTensorComputation")
-internal func _TFCFinishTensorComputation(
-  _ computation: _TensorComputation,
-  _ tensorResultAddress: UnsafeMutablePointer<CTensorHandle>,
-  _ tensorResultCount: Int
-) {
-  debugLog("Expecting \(tensorResultCount) output tensors.")
-  let results = computation.finish()
-  internalConsistencyCheck(results.count == tensorResultCount,
-    "internal compiler error: result count mismatch!")
-  tensorResultAddress.initialize(from: results, count: tensorResultCount)
-}
-
-/// Terminates the computation as given by 'program', and clean up the state.
-///
-/// - Parameters:
-///   - program: The tensor program to terminate.
-/// - Note: If the execution was synchronous, then this function does nothing.
-@usableFromInline
-@_silgen_name("_swift_tfc_TerminateTensorComputation")
-internal func _TFCTerminateTensorComputation(_ computation: _TensorComputation) {
-  computation.terminate()
-}
-
-/// Registers all functions in a graph into the eager context if in eager mode.
-///
-/// - Parameters:
-///   - programByteAddress: The address of the raw program.
-///   - programByteCount: The number of bytes in the program.
-@usableFromInline
-@_silgen_name("_swift_tfc_RegisterTensorFunctions")
-internal func _TFCRegisterTensorFunctions(
-  _ programByteAddress: UnsafeRawPointer,
-  _ programByteCount: Int
-) {
-  _ExecutionContext.global.loadFunctionsFromGraph(byteAddress: programByteAddress,
-                                                  byteCount: programByteCount)
-}
-
-/// Creates a scalar CTensorHandle value for the given data type.
-///
-/// - Parameters:
-///   - value: The scalar value.
-///   - dtype: The TF data type of the tensor handle to create.
-/// - Returns: A new CTensorHandle representing the scalar.
-/// - Precondition: T must conform to _TensorFlowDataTypeCompatible and 'dtype'
-///   must be equal to T's corresponding data type.
-/// - TODO(rxwei): Constrain T to _TensorFlowDataTypeCompatible and remove the
-///   precondition. This requires the compiler to emit a call to the generic
-///   function.
-@usableFromInline
-@_silgen_name("_swift_tfc_CreateCTensorHandle")
-internal func _TFCCreateCTensorHandle<T>(_ value: T,
-                                         _ dtype: TF_DataType) -> CTensorHandle {
-  // Create a new CTensor and initialize it to the scalar value.
-  let tensor = TF_AllocateTensor(dtype, nil, 0, MemoryLayout<T>.stride)
-  TF_TensorData(tensor).assumingMemoryBound(to: T.self).initialize(to: value)
-  // Create a new CTensorHandle from the CTensor.
-  let status = TF_NewStatus()
-  let cTensorHandle = TFE_NewTensorHandle(tensor, status)
-  checkOk(status)
-  TF_DeleteStatus(status)
-  TF_DeleteTensor(tensor)
-  return cTensorHandle!
-}
-
 //===----------------------------------------------------------------------===//
 // - MARK: Dynamic compilation (per-op dispatch) entrypoints
 //===----------------------------------------------------------------------===//
@@ -1779,42 +1621,6 @@ func _TFCOpAddInputFromAnyTensors(
   }
 }
 
-/// Initializes a TensorGroup value, taking ownership of all the tensor
-/// handles in `tensorHandles`.
-@usableFromInline
-@_silgen_name("_swift_tfc_InitTensorGroup")
-func _TFCInitTensorGroup<T : TensorGroup>(
-    _ tensorHandles: UnsafeMutablePointer<CTensorHandle>
-) -> T {
-  return T(_owning: tensorHandles)
-}
-
-/// Allocates a buffer of CTensorHandles on the heap.
-@usableFromInline
-@_silgen_name("_swift_tfc_AllocateCHandleBuffer")
-func _TFCAllocateCHandleBuffer(_ capacity: Int32)
-    -> UnsafeMutablePointer<CTensorHandle> {
-  return UnsafeMutablePointer.allocate(capacity: Int(capacity))
-}
-
-/// Deallocates a buffer of CTensorHandles.
-@usableFromInline
-@_silgen_name("_swift_tfc_DeallocateCHandleBuffer")
-func _TFCDeallocateCHandleBuffer(
-    _ buffer: UnsafeMutablePointer<CTensorHandle>
-) {
-  buffer.deallocate()
-}
-
-/// Returns the number of CTensorHandles in a TensorGroup of type T.
-@usableFromInline
-@_silgen_name("_swift_tfc_GetTensorGroupCHandleCount")
-internal func _TFCGetTensorGroupCHandleCount<T : TensorGroup>(
-    _ type: T.Type
-) -> Int32 {
-  return T._tensorHandleCount
-}
-
 @inlinable
 @_silgen_name("_swift_tfc_CreateTensorHandleFromC")
 public func _TFCCreateTensorHandleFromC(
@@ -1845,56 +1651,6 @@ public func _TFCCreateTensorHandleFromC(
 // functions. The wrappers handle converting the Swift Stdlib Array<T> values
 // into buffers that TFE_OpSetAttr*List functions can read.
 
-@usableFromInline
-@_silgen_name("_swift_tfc_OpSetAttrBoolArray")
-func _TFCOpSetAttrBoolArray(_ op: CTFEOp,
-                            _ attrName: UnsafePointer<Int8>,
-                            _ value: Array<Bool>) {
-  value.map({ $0 ? UInt8(1) : UInt8(0) }).withUnsafeBufferPointer { buffer in
-    TFE_OpSetAttrBoolList(op, attrName, buffer.baseAddress, Int32(buffer.count))
-  }
-}
-
-@usableFromInline
-@_silgen_name("_swift_tfc_OpSetAttrInt32Array")
-func _TFCOpSetAttrInt32Array(_ op: CTFEOp,
-                             _ attrName: UnsafePointer<Int8>,
-                             _ value: Array<Int32>) {
-  value.map(Int64.init).withUnsafeBufferPointer { buffer in
-    TFE_OpSetAttrIntList(op, attrName, buffer.baseAddress, Int32(buffer.count))
-  }
-}
-
-@usableFromInline
-@_silgen_name("_swift_tfc_OpSetAttrInt64Array")
-func _TFCOpSetAttrInt64Array(_ op: CTFEOp,
-                             _ attrName: UnsafePointer<Int8>,
-                             _ value: Array<Int64>) {
-  value.withUnsafeBufferPointer { buffer in
-    TFE_OpSetAttrIntList(op, attrName, buffer.baseAddress, Int32(buffer.count))
-  }
-}
-
-@usableFromInline
-@_silgen_name("_swift_tfc_OpSetAttrDoubleArray")
-func _TFCOpSetAttrDoubleArray(_ op: CTFEOp,
-                              _ attrName: UnsafePointer<Int8>,
-                              _ value: Array<Double>) {
-  value.map(Float.init).withUnsafeBufferPointer { buffer in
-    TFE_OpSetAttrFloatList(op, attrName, buffer.baseAddress, Int32(buffer.count))
-  }
-}
-
-@usableFromInline
-@_silgen_name("_swift_tfc_OpSetAttrFloatArray")
-func _TFCOpSetAttrFloatArray(_ op: CTFEOp,
-                             _ attrName: UnsafePointer<Int8>,
-                             _ value: Array<Float>) {
-  value.withUnsafeBufferPointer { buffer in
-    TFE_OpSetAttrFloatList(op, attrName, buffer.baseAddress, Int32(buffer.count))
-  }
-}
-
 @usableFromInline
 @_silgen_name("_swift_tfc_OpSetAttrTypeArray")
 func _TFCOpSetAttrTypeArray(_ op: CTFEOp,
@@ -1908,61 +1664,6 @@ func _TFCOpSetAttrTypeArray(_ op: CTFEOp,
   }
 }
 
-@usableFromInline
-@_silgen_name("_swift_tfc_OpSetAttrTensorShape")
-func _TFCOpSetAttrTensorShape(_ op: CTFEOp,
-                              _ attrName: UnsafePointer<Int8>,
-                              _ shape: TensorShape,
-                              _ status: CTFStatus) {
-  let dimensions: [Int64] = shape.dimensions.map(Int64.init)
-  dimensions.withUnsafeBufferPointer { buffer in
-    TFE_OpSetAttrShape(op, attrName, buffer.baseAddress, Int32(buffer.count),
-                       status)
-  }
-}
-
-@usableFromInline
-@_silgen_name("_swift_tfc_OpSetAttrOptionalTensorShape")
-func _TFCOpSetAttrOptionalTensorShape(_ op: CTFEOp,
-                                      _ attrName: UnsafePointer<Int8>,
-                                      _ optionalShape: TensorShape?,
-                                      _ status: CTFStatus) {
-  guard let shape = optionalShape else {
-    TFE_OpSetAttrShape(op, attrName, nil, -1, status)
-    return
-  }
-  _TFCOpSetAttrTensorShape(op, attrName, shape, status)
-}
-
-@usableFromInline
-@_silgen_name("_swift_tfc_OpSetAttrTensorShapeArray")
-func _TFCOpSetAttrTensorShapeArray(_ op: CTFEOp,
-                                   _ attrName: UnsafePointer<Int8>,
-                                   _ value: Array<TensorShape>,
-                                   _ status: CTFStatus) {
-  let flattenedDims = value.flatMap { $0.dimensions.map(Int64.init) }
-  let ranks = value.map { Int32($0.rank) }
-  setAttrShapeList(op: op, attrName: attrName, flattenedDims: flattenedDims,
-                   ranks: ranks, status: status)
-}
-
-@usableFromInline
-@_silgen_name("_swift_tfc_OpSetAttrOptionalTensorShapeArray")
-func _TFCOpSetAttrOptionalTensorShapeArray(_ op: CTFEOp,
-                                           _ attrName: UnsafePointer<Int8>,
-                                           _ value: Array<TensorShape?>,
-                                           _ status: CTFStatus) {
-  let flattenedDims = value.flatMap { (tensorShapeOpt) -> [Int64] in
-    if let tensorShape = tensorShapeOpt {
-      return tensorShape.dimensions.map(Int64.init)
-    }
-    return []
-  }
-  let ranks = value.map { shape in (shape?.rank).map(Int32.init) ?? -1 }
-  setAttrShapeList(op: op, attrName: attrName, flattenedDims: flattenedDims,
-                   ranks: ranks, status: status)
-}
-
 /// Given dimensions and ranks in the form described below, makes the
 /// appropriate call to `TFE_OpSetAttrShapeList(op, attrName, ..., status)`.
 ///
@@ -1993,74 +1694,6 @@ fileprivate func setAttrShapeList(
   }
 }
 
-/// Wrapper around TFE_OpSetAttrString that handles converting the Swift Stdlib
-/// String into a buffer that TFE_OpSetAttrString can read.
-@usableFromInline
-@_silgen_name("_swift_tfc_OpSetAttrString")
-func _TFCOpSetAttrString(_ op: CTFEOp,
-                         _ attrName: UnsafePointer<Int8>,
-                         _ value: String) {
-  value.utf8CString.withUnsafeBufferPointer { buffer in
-    // utf8CString is null-terminated; TFE_OpSetAttrString wants
-    // non-null-terminated.
-    TFE_OpSetAttrString(op, attrName, buffer.baseAddress, buffer.count - 1)
-  }
-}
-
-/// Wrapper around TFE_OpSetAttrFunctionName that handles converting the Swift
-/// Stdlib String into a buffer that TFE_OpSetAttrFunctionName can read.
-@usableFromInline
-@_silgen_name("_swift_tfc_OpSetAttrFunctionName")
-func _TFCOpSetAttrFunctionName(_ op: CTFEOp,
-                               _ attrName: UnsafePointer<Int8>,
-                               _ value: String) {
-  value.utf8CString.withUnsafeBufferPointer { buffer in
-    // utf8CString is null-terminated; TFE_OpSetAttrFunctionName wants
-    // non-null-terminated.
-    TFE_OpSetAttrFunctionName(op, attrName, buffer.baseAddress, buffer.count - 1)
-  }
-}
-
-/// Wrapper around TFE_OpSetAttrStringList that handles converting the Swift
-/// Strings into buffers that TFE_OpSetAttrStringList can read.
-@usableFromInline
-@_silgen_name("_swift_tfc_OpSetAttrStringArray")
-func _TFCOpSetAttrStringArray(_ op: CTFEOp,
-                             _ attrName: UnsafePointer<Int8>,
-                             _ strings: [String]) {
-  // Collect all the strings' utf8 bytes into a single array so that we can
-  // address all the strings with a single
-  // `flattenedStringBytes.withUnsafeBufferPointer`.
-  var flattenedStringBytes: [CChar] = []
-  var lengths: [Int] = []
-  for string in strings {
-    // Don't include the null-terminator because TFE_OpSetAttrStringList uses
-    // lengths instead of null-terminators.
-    let stringBytes = string.utf8CString.dropLast()
-    flattenedStringBytes.append(contentsOf: stringBytes)
-    lengths.append(stringBytes.count)
-  }
-
-  // Calculate the addresses of all the strings within our single buffer, and
-  // then call TFE_OpSetAttrStringList.
-  flattenedStringBytes.withUnsafeBufferPointer { flattenedStringBytesBuffer in
-    var stringAddrs: [UnsafeRawPointer?] = []
-    var currentStringAddr =
-        flattenedStringBytesBuffer.baseAddress.map(UnsafeRawPointer.init)
-    for length in lengths {
-      stringAddrs.append(currentStringAddr)
-      currentStringAddr = currentStringAddr?.advanced(by: length)
-    }
-
-    stringAddrs.withUnsafeBufferPointer { stringAddrsBuffer in
-      lengths.withUnsafeBufferPointer { lengthsBuffer in
-        TFE_OpSetAttrStringList(op, attrName, stringAddrsBuffer.baseAddress,
-                                lengthsBuffer.baseAddress, Int32(strings.count))
-      }
-    }
-  }
-}
-
 @usableFromInline
 class _ThreadLocalState {
   var deviceScopes: [(kind: DeviceKind, index: UInt)?] = []
@@ -2109,9 +1742,3 @@ func _TFCOpSetDeviceFromScope(_ op: CTFEOp, _ status: CTFStatus) {
     TFE_OpSetDevice(op, deviceName, status)
   }
 }
-
-@usableFromInline
-@_cdecl("_swift_tfc_CheckOk")
-func _TFCCheckOk(_ s: CTFStatus) {
-  checkOk(s)
-}
diff --git a/Sources/TensorFlow/Core/Tensor.swift b/Sources/TensorFlow/Core/Tensor.swift
index 9211d023a..0f3c609a3 100644
--- a/Sources/TensorFlow/Core/Tensor.swift
+++ b/Sources/TensorFlow/Core/Tensor.swift
@@ -551,13 +551,5 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
 
 extension Tensor: Differentiable where Scalar: TensorFlowFloatingPoint {
     public typealias TangentVector = Tensor
-    public typealias CotangentVector = Tensor
     public typealias AllDifferentiableVariables = Tensor
-
-    @inlinable
-    public func tangentVector(
-        from cotangent: CotangentVector
-    ) -> TangentVector {
-        return cotangent
-    }
 }
diff --git a/Sources/TensorFlow/Operators/Basic.swift b/Sources/TensorFlow/Operators/Basic.swift
index 5e6a3c3ac..b0bfa4931 100644
--- a/Sources/TensorFlow/Operators/Basic.swift
+++ b/Sources/TensorFlow/Operators/Basic.swift
@@ -205,7 +205,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
     @inlinable
     func _vjpUnstacked(
         alongAxis axis: Int = 0
-    ) -> ([Tensor], (Array<Tensor>.CotangentVector) -> Tensor) {
+    ) -> ([Tensor], (Array<Tensor>.TangentVector) -> Tensor) {
         let result = unstacked(alongAxis: axis)
         return (result, { v in Tensor(stacking: v.base, alongAxis: axis) })
     }
@@ -214,7 +214,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
     func _vjpSplit(
         count: Int,
         alongAxis axis: Int = 0
-    ) -> ([Tensor], (Array<Tensor>.CotangentVector) -> Tensor) {
+    ) -> ([Tensor], (Array<Tensor>.TangentVector) -> Tensor) {
         let result = split(count: count, alongAxis: axis)
         return (result, { v in Tensor(concatenating: v.base, alongAxis: axis) })
     }
@@ -223,7 +223,7 @@ internal extension Tensor where Scalar: TensorFlowFloatingPoint {
     func _vjpSplit(
         sizes: Tensor<Int32>,
         alongAxis axis: Int = 0
-    ) -> ([Tensor], (Array<Tensor>.CotangentVector) -> Tensor) {
+    ) -> ([Tensor], (Array<Tensor>.TangentVector) -> Tensor) {
         let result = split(sizes: sizes, alongAxis: axis)
         return (result, { v in Tensor(concatenating: v.base, alongAxis: axis) })
     }

From 77ed8df80416940de45cfa9bf875103b6e962d90 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Wed, 22 May 2019 11:27:58 -0400
Subject: [PATCH 33/55] [AutoDiff] TF-509: Make 'Tensor.broadcasted(to:)'
 differentiable.

---
 Sources/TensorFlow/Operators/Basic.swift | 29 ++++++++++++++++++++++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/Sources/TensorFlow/Operators/Basic.swift b/Sources/TensorFlow/Operators/Basic.swift
index b0bfa4931..08f4b35f4 100644
--- a/Sources/TensorFlow/Operators/Basic.swift
+++ b/Sources/TensorFlow/Operators/Basic.swift
@@ -361,23 +361,27 @@ infix operator .=
 
 public extension Tensor {
     @inlinable
+    @differentiable(wrt: self, vjp: _vjpBroadcasted(toShape:) where Scalar: TensorFlowFloatingPoint)
     func broadcasted(toShape shape: Tensor<Int32>) -> Tensor {
         return Raw.broadcastTo(self, shape: shape)
     }
 
     @inlinable
+    @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
     func broadcasted(to shape: TensorShape) -> Tensor {
-        return broadcasted(toShape: Tensor<Int32>(shape.dimensions.map(Int32.init)))
+        return broadcasted(toShape: Tensor<Int32>({ shape.dimensions.map(Int32.init) }()))
     }
 
     /// Broadcast to the same shape as the specified `Tensor`.
     /// - Precondition: The specified shape must be compatible for broadcasting.
     @inlinable
+    @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
     func broadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor {
         return broadcasted(toShape: other.shapeTensor)
     }
 
     @inlinable
+    @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
     static func .= (lhs: inout Tensor, rhs: Tensor) {
         lhs = rhs.broadcasted(like: lhs)
     }
@@ -385,6 +389,9 @@ public extension Tensor {
 
 public extension Tensor where Scalar: Numeric {
     @inlinable
+    @differentiable(
+        wrt: self,
+        vjp: _vjpUnbroadcasted(toShape:) where Scalar: TensorFlowFloatingPoint)
     func unbroadcasted(toShape otherShape: Tensor<Int32>) -> Tensor {
         let rankDiff = (rankTensor - otherShape.scalarCountTensor).rankLifted()
         let ones = Raw.fill(dims: rankDiff, value: Tensor<Int32>(1))
@@ -394,13 +401,31 @@ public extension Tensor where Scalar: Numeric {
     }
 
     @inlinable
+    @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
     func unbroadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor {
         return unbroadcasted(toShape: other.shapeTensor)
     }
 
     @inlinable
+    @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
     func unbroadcasted(to shape: TensorShape) -> Tensor {
-        return unbroadcasted(toShape: Tensor<Int32>(shape.dimensions.map(Int32.init)))
+        return unbroadcasted(toShape: Tensor<Int32>({ shape.dimensions.map(Int32.init) }()))
+    }
+}
+
+extension Tensor where Scalar: TensorFlowFloatingPoint {
+    @inlinable
+    func _vjpBroadcasted(toShape shape: Tensor<Int32>) -> (Tensor, (Tensor) -> Tensor) {
+        return (broadcasted(toShape: shape), { [originalShape = self.shapeTensor] v in
+            v.unbroadcasted(toShape: originalShape)
+        })
+    }
+
+    @inlinable
+    func _vjpUnbroadcasted(toShape shape: Tensor<Int32>) -> (Tensor, (Tensor) -> Tensor) {
+        return (unbroadcasted(toShape: shape), { [originalShape = self.shapeTensor] v in
+            v.broadcasted(toShape: originalShape)
+        })
     }
 }
 

From bd27b8edc84825969a6adffeb4c8e3d58c91b50d Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Wed, 22 May 2019 11:29:58 -0400
Subject: [PATCH 34/55] [TF] Fix 'Tensor.replacing(_:_:)' wrong semantics.

---
 Sources/TensorFlow/Operators/Math.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/TensorFlow/Operators/Math.swift b/Sources/TensorFlow/Operators/Math.swift
index c24b3ac21..14ae6aa31 100644
--- a/Sources/TensorFlow/Operators/Math.swift
+++ b/Sources/TensorFlow/Operators/Math.swift
@@ -825,7 +825,7 @@ public extension Tensor {
     @inlinable
     @differentiable(wrt: (self, other), vjp: _vjpReplacing where Scalar: TensorFlowFloatingPoint)
     func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor {
-        return Raw.select(condition: mask, t: self, e: other)
+        return Raw.select(condition: mask, t: other, e: self)
     }
 }
 

From c58709ef7b0fec211d4c055635034e3712b9dc30 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Wed, 22 May 2019 11:30:45 -0400
Subject: [PATCH 35/55] Correct '_vjpRsqrt' to match 'Raw.rsqrtGrad'.

---
 Sources/TensorFlow/Operators/Math.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/TensorFlow/Operators/Math.swift b/Sources/TensorFlow/Operators/Math.swift
index 14ae6aa31..cc3cb23fa 100644
--- a/Sources/TensorFlow/Operators/Math.swift
+++ b/Sources/TensorFlow/Operators/Math.swift
@@ -553,7 +553,7 @@ internal func _vjpRsqrt<T: TensorFlowFloatingPoint>(
     _ x: Tensor<T>
 ) -> (Tensor<T>, (Tensor<T>) -> Tensor<T>) {
     let value = rsqrt(x)
-    return (value, { v in -v / 2 * value })
+    return (value, { v in -v / (2 * pow(x, 3 / 2)) })
 }
 
 /// Computes `exp` of the specified tensor element-wise.

From acfa5015307cbe8cfdc9b3eac8dca33506f8cb26 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Wed, 22 May 2019 11:33:07 -0400
Subject: [PATCH 36/55] [TF-504] Remove irrelevant fields in _ExecutionContext.

---
 Sources/TensorFlow/Core/Runtime.swift | 395 --------------------------
 1 file changed, 395 deletions(-)

diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index a3467b52b..21d0c6bc6 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -613,11 +613,6 @@ public final class _ExecutionContext {
   @usableFromInline
   internal let eagerContext: CTFEContext
 
-  // NOTE: the following properties are intentionally not implemented as an enum
-  // due to high churn, *please do not refactor for Swiftiness*.
-  /// The set of all loaded programs indexed by their unique address.
-  private var loadedPrograms: [UnsafeRawPointer : CTFGraph] = [:]
-
   /// The status for checking TensorFlow errors.
   private let status: CTFStatus = TF_NewStatus()
 
@@ -1103,66 +1098,6 @@ internal extension _ExecutionContext {
   }
 }
 
-fileprivate extension _ExecutionContext {
-  /// Load the graph functions of a serialized TensorFlow GraphDef binary proto
-  /// into the context, if that has not been done yet. Return the graph.
-  /// - Parameters:
-  ///   - address: The address of the serialized program in memory.
-  ///   - count: The size of the program in bytes.
-  func loadProgramInBytes(_ address: UnsafeRawPointer, count: Int) -> CTFGraph {
-    return sync {
-      debugLog("Loading a program.")
-       // If the program is already loaded, do nothing.
-      if let graph = loadedPrograms[address] {
-        return graph
-      }
-      // Here we have to do a fairly awkward dance to load the graph functions
-      // and populate them into the TFE_Context.  We load the program as a
-      // TF_Graph, then copy the functions out of it, then copy them into the
-      // TFE_Context.
-      debugLog("Loading graph functions.")
-      let graph = TF_NewGraph()!
-      // TensorFlow loads things through TF_Buffer.  Create one that avoids
-      // redundantly copying the program bytes.
-      var programBuf = TF_Buffer(data: address, length: count,
-                                 data_deallocator: nil)
-      let graphDefOptions = TF_NewImportGraphDefOptions()
-      TF_GraphImportGraphDef(graph, &programBuf, graphDefOptions, self.status)
-      TF_DeleteImportGraphDefOptions(graphDefOptions)
-      checkOk(self.status)
-      // Now that we have all of the TF_Function objects in the graph, copy them
-      // to standalone TF_Function's.
-      let funcCount = TF_GraphNumFunctions(graph)
-      // Allocate an array to accept functions.
-      var funcs: [CTFFunction?] = Array(repeating: nil, count: Int(funcCount))
-      TF_GraphGetFunctions(graph, &funcs, funcCount, self.status)
-      checkOk(self.status)
-
-      // Add functions to the context.
-      debugLog("Adding \(funcCount) functions to context.")
-      for function in UnsafeBufferPointer(start: funcs, count: Int(funcCount)) {
-        TFE_ContextAddFunction(self.eagerContext, function, self.status)
-        checkOk(self.status)
-        debugLog("Added func \(String(cString: TF_FunctionName(function))).")
-        TF_DeleteFunction(function)
-      }
-
-       // Memorize the loaded program by address.
-      loadedPrograms[address] = graph
-      debugLog("Done loading a new program.")
-      return graph
-    }
-  }
-}
-
-public extension _ExecutionContext {
-  /// Load functions from a graph encoded as a byte-pointer and length into the
-  /// tensorflow eagerContext.
-  func loadFunctionsFromGraph(byteAddress: UnsafeRawPointer, byteCount: Int) {
-    _ = loadProgramInBytes(byteAddress, count: byteCount)
-  }
-}
-
 @usableFromInline
 internal func dumpTensorContent<Scalar : _TensorFlowDataTypeCompatible>(
   _ inputTensor: CTensorHandle, _: Scalar.Type
@@ -1207,336 +1142,6 @@ internal func dumpCTensorHandleContent(
   }
 }
 
-private class TFEState {
-  let status: CTFStatus = TF_NewStatus()
-  /// The set of graph functions to be concurrently executed (as TFE ops).
-  ///
-  /// The first one is on the primary device, handling input and output
-  /// tensors. The other ones are helper functions that are executed only for
-  /// their side effects (e.g. sending and receiving tensors with the primary
-  /// function).
-  var ops: [CTFEOp] = []
-  init(_ programByteAddress: UnsafeRawPointer,
-       programByteCount: Int,
-       helperFunctionCount: Int,
-       entryFunctionBaseNameAddress: UnsafePointer<Int8>) {
-
-    // Given an input like "foo.tf_13" (prefix if a SIL graph function like
-    // "foo.tf_13_CPU.device_partition"), extract and return "13" as the device
-    // index.
-    func deviceIndexSubstring(from opTypePrefix: Substring) -> Substring {
-      let underscorePos = opTypePrefix.lastIndex(of: "_")
-      internalConsistencyCheck(
-        underscorePos != nil,
-        "Malformed op type prefix \(opTypePrefix)")
-      let startPos = opTypePrefix.index(after: underscorePos!)
-      let deviceIndexStr = opTypePrefix.suffix(from: startPos)
-      return deviceIndexStr
-    }
-
-    let context = _ExecutionContext.global
-    // Make sure the program is loaded into the context.
-    let graph = context.loadProgramInBytes(programByteAddress,
-                                           count: programByteCount)
-
-    let entryFunctionBaseName = String(cString: entryFunctionBaseNameAddress)
-    debugLog("Looking up op(s) from func base name \(entryFunctionBaseName).")
-    for i in 0...helperFunctionCount {
-      // Also look up in the TensorFlow program a function name (op type) based
-      // on the op name. e.g. given op name "tfc_func_S4mainyycfU_.tf", return
-      // op type "S4mainyycfU_.tf_CPU.device_partition". TFE ops are created by
-      // the op types.
-      var opName = "tfc_func_" + entryFunctionBaseName;
-      if i > 0 {
-        opName += "_helper_\(i-1)"
-      }
-      let funcNode = TF_GraphOperationByName(graph, opName)
-      internalConsistencyCheck(
-        funcNode != nil,
-        "Cannot find func node name \(opName)"
-      )
-
-      let opType = String(cString: TF_OperationOpType(funcNode))
-      debugLog("Creating a new op based on type \(opType).")
-      let op: CTFEOp? = TFE_NewOp(context.eagerContext, opType, status)
-      checkOk(status)
-      let deviceName: String?
-      if opType.hasSuffix("_RUNTIME.device_partition") {
-        deviceName = _ExecutionContext.global.currentDeviceName
-      } else if opType.hasSuffix("_CPU.device_partition") {
-        // The op type can be: tmp3_main.tf_17_CPU.device_partition. We want to
-        // extract the device index "17" out of the above name, and use it to
-        // form a TF device string like
-        // "/job:localhost/replica:0/task:0/device:CPU:17".
-        let opTypePrefix = opType.dropLast("_CPU.device_partition".count)
-        let deviceIndexStr = deviceIndexSubstring(from: opTypePrefix)
-        deviceName = context.cpuDeviceNamePrefix + deviceIndexStr
-      } else {
-        // TODO: support TPU as well.
-        internalConsistencyCheck(opType.hasSuffix("_GPU.device_partition"))
-        internalConsistencyCheck(context.gpuDeviceNamePrefix != nil)
-        let opTypePrefix = opType.dropLast("_GPU.device_partition".count)
-        let deviceIndexStr = deviceIndexSubstring(from: opTypePrefix)
-        deviceName = context.gpuDeviceNamePrefix! + deviceIndexStr
-      }
-      if let deviceName = deviceName {
-        debugLog("Placing the op on device \(deviceName).")
-        TFE_OpSetDevice(op, deviceName, status)
-        checkOk(status)
-      } else {
-        debugLog("Not placing the op on any device.")
-      }
-      ops.append(op!)
-    }
-  }
-  deinit {
-    for op in ops {
-      TFE_DeleteOp(op)
-    }
-    TF_DeleteStatus(status)
-  }
-}
-
-extension TFEState {
-  func addInput(_ inputTensorHandle: CTensorHandle) {
-    TFE_OpAddInput(ops[0], inputTensorHandle, status)
-  }
-}
-
-//===----------------------------------------------------------------------===//
-// - MARK: Tensor computation
-//===----------------------------------------------------------------------===//
-
-/// Tensor computation.
-///
-/// - Note: The call sequence for the APIs below must be one of the two:
-///   `init -> terminate()` or `init -> finish()`.
-///   The finish/terminate APIs may only be called once.
-@_fixed_layout
-public final class _TensorComputation {
-  /// The status for checking TensorFlow errors.
-  let status: CTFStatus = TF_NewStatus()
-
-  /// The base name for the set of graph functions to execute in this instance.
-  let entryFunctionBaseName: String
-
-  /// The number of helper functions associated with this TF graph
-  /// execution. For a graph execution over N TF devices, there is a single
-  /// *primary* graph function, responsible for taking input and producing
-  /// output tensors as part of the SessionRun() spec. The other N-1 graph
-  /// functions are *helper* functions, executed together with the primary one
-  /// for their side-effects, such as sending/receiving tensors, "helping" the
-  /// primary function produce the desired output tensors and side effects as
-  /// needed by the SessionRun() call.
-  let helperFunctionCount: Int
-
-  /// The tensor handles returned by the tensor program.
-  // TODO(hongm): Retire returnValues when eager based runtime is removed.
-  var returnValues: [CTensorHandle?]
-
-  private var state: TFEState
-
-  /// The threads to run tensor computation in. In eager mode, we use N threads
-  /// when the tensor computation involves N device functions. In non-eager
-  /// mode, we use a single thread (that's sufficient as these N device
-  /// functions can be sent to the same TF_SessionRun() call.)
-  ///
-  /// This property is non-empty only when the tensor computation is on-going.
-  private var pthreads: [pthread_t] = []
-
-  /// The data structure to pass into pthread creation API.
-  /// We cannot have the ThreadBody closure below close over on `threadIndex`,
-  /// because ThreadBody is of C convention.
-  private class ThreadParam {
-    let computation: _TensorComputation
-    let threadIndex: Int
-
-    init(computation: _TensorComputation, threadIndex: Int) {
-      self.computation = computation
-      self.threadIndex = threadIndex
-    }
-  }
-
-  /// Loads the TF program from a binary TF FunctionDef proto given by
-  /// 'programByteAddress' and 'programByteCount', and start the computation.
-  ///
-  /// - Parameters:
-  ///   - programByteAddress: The address of the raw program.
-  ///   - programByteCount: The number of bytes in the program.
-  ///   - entryFunctionBaseNameAddress: The base name of the functions to run.
-  ///   - tensorArgumentAddress: The address to the buffer containing tensor
-  ///     arguments as CTensorHandle.
-  ///   - tensorArgumentCount: The number of tensor arguments to pass in.
-  ///   - helperFunctionCount: The number of helper functions to run.
-  ///   - resultCount: The number of output tensors.
-  ///
-  /// - TODO(clattner): `resultCount` should go away when the runtime is
-  ///   implemented with an async design.
-  @usableFromInline
-  init(programByteAddress: UnsafeRawPointer,
-       programByteCount: Int,
-       entryFunctionBaseNameAddress: UnsafePointer<Int8>,
-       tensorArgumentAddress: UnsafePointer<CTensorHandle>,
-       tensorArgumentCount: Int,
-       helperFunctionCount: Int,
-       resultCount: Int) {
-    configureRuntimeFromEnvironment()
-
-    let inputTensorHandles = UnsafeBufferPointer(start: tensorArgumentAddress,
-                                                 count: tensorArgumentCount)
-
-    // Initialize global execution context if that's not yet done. It caches all
-    // our tensor programs.
-    _ = _ExecutionContext.global
-
-    if _RuntimeConfig.printsDebugLog {
-      let buffer = UnsafeBufferPointer(
-        start: programByteAddress.assumingMemoryBound(to: UInt8.self),
-        count: programByteCount)
-      debugLog("The program bytes are \(Array(buffer)).")
-    }
-
-    // Now that we have them in our context, we can get ready to get the top
-    // level function and create an op.
-    self.entryFunctionBaseName = String(cString: entryFunctionBaseNameAddress)
-    debugLog("""
-      Creating a new op with func base name \
-      \(String(cString: entryFunctionBaseNameAddress)).
-      """)
-    self.helperFunctionCount = helperFunctionCount
-    self.state = TFEState(
-        programByteAddress,
-        programByteCount: programByteCount,
-        helperFunctionCount: helperFunctionCount,
-        entryFunctionBaseNameAddress: entryFunctionBaseNameAddress)
-      debugLog("Done initializing TFE-specific state.")
-
-    debugLog("Populating the op's input list.")
-    for (i, inputTensorHandle) in inputTensorHandles.enumerated() {
-      if _RuntimeConfig.printsDebugLog {
-        dumpCTensorHandleContent(i, inputTensorHandle)
-      }
-      state.addInput(inputTensorHandle)
-    }
-
-    debugLog("Created returning info.")
-    self.returnValues = Array(repeating: nil, count: resultCount)
-
-    debugLog("Starting TF graph execution.")
-
-    // If it's asynchronous, we execute the tensor computation via threads.
-    let threadCount = helperFunctionCount + 1
-	  for threadIndex in 0..<threadCount {
-	    // The function to launch in the parallel thread.
-#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
-      typealias ThreadBody = @convention(c)
-        (UnsafeMutableRawPointer) -> UnsafeMutableRawPointer?
-#else
-      typealias ThreadBody = @convention(c)
-        (UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer?
-#endif
-      let body: ThreadBody = { arg in
-        // Set the cancelability of the detached thread.
-        pthread_setcanceltype(Int32(PTHREAD_CANCEL_DEFERRED), nil)
-        // Execute the tensor computation.
-#if !(os(macOS) || os(iOS) || os(watchOS) || os(tvOS))
-        let arg = arg!
-#endif
-        let param: ThreadParam =
-          Unmanaged.fromOpaque(arg).takeRetainedValue()
-        param.computation.execute(threadIndex: param.threadIndex)
-        checkOk(param.computation.status)
-        return nil
-      }
-#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
-      var newThread: pthread_t!
-#else
-      var newThread = pthread_t()
-#endif
-        let creationStatus = pthread_create(
-	        &newThread, nil, body,
-	        Unmanaged.passRetained(
-	          ThreadParam(computation: self,
-	                      threadIndex: threadIndex)).toOpaque()
-	      )
-	      // TODO(hongm): do error handling.
-	      internalConsistencyCheck(creationStatus == 0)
-	      pthreads.append(newThread)
-    }
-    debugLog("Exiting _TensorComputation.init().")
-  }
-
-  deinit {
-    debugLog("De-initializing _TensorComputation.")
-    TF_DeleteStatus(status)
-  }
-}
-
-private extension _TensorComputation {
-  /// In eager mode, runs a device function in a corresponding thread given by
-  /// `threadIndex`. Otherwise, runs all devices functions of the tensor
-  /// program. Aborts the process on error, and emits an error string to STDERR.
-  // NOTE: This is to be called by the initializer. The computation gets
-  // executed on initialization, thus this method will not be exposed to users.
-  private func execute(threadIndex: Int) {
-    debugLog("Executing thread \(threadIndex).")
-    internalConsistencyCheck(threadIndex <= helperFunctionCount)
-    let op = state.ops[threadIndex]
-    if threadIndex == 0 {
-      var returnValueCount = Int32(returnValues.count)
-      TFE_Execute(op, &returnValues, &returnValueCount, status)
-      debugLog("""
-                 returnValues.count=\(returnValues.count), \
-                 returnValueCount=\(returnValueCount).
-                 """)
-      internalConsistencyCheck(returnValueCount == returnValues.count)
-    } else {
-      var returnValueCountForHelper: Int32 = 0
-      TFE_Execute(op, /*returnValues*/nil, &returnValueCountForHelper, status)
-      internalConsistencyCheck(returnValueCountForHelper == 0)
-    }
-    checkOk(status)
-
-    debugLog("Done execution with eager.")
-  }
-}
-
-internal extension _TensorComputation {
-  /// Terminates the computation, and clean up the state.
-  func terminate() {
-    for pthread in pthreads {
-      // TODO(hongm): Assess TF's thread cancel support.
-      let cancelStatus = pthread_cancel(pthread)
-      internalConsistencyCheck(cancelStatus == 0)
-    }
-    pthreads.removeAll()
-  }
-
-  /// Waits for completion the computation as given by 'program', and returns
-  /// output handles, whose underlying tensors may live on CPU or GPU.
-  /// Aborts the process on error, and emits an error string to STDERR.
-  func finish() -> [CTensorHandle] {
-    debugLog("Calling _TensorComputation.finish().")
-    if pthreads.isEmpty {
-      fatalError("""
-          finish() is called in async execution mode with pthread == nil -- \
-          Was finish() already called?
-          """)
-    }
-    for pthread in pthreads {
-      debugLog("Waiting for thread to join.")
-      let joinStatus = pthread_join(pthread, nil)
-      internalConsistencyCheck(joinStatus == 0)
-    }
-    pthreads.removeAll()
-    debugLog("Done executing TF graph.")
-
-    // Now that all the elements have been filled in, remove a level of
-    // optional.
-    return returnValues.map { $0! }
-  }
-}
-
 @inlinable
 @_cdecl("_swift_tfc_EagerExecute")
 internal func _TFCEagerExecute(_ op: CTFEOp,

From bcbf6d0eaf5802ceaaf82b153ffe5f6e18c05689 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Wed, 22 May 2019 11:40:01 -0400
Subject: [PATCH 37/55] [TF] Reimplement unbroadcast using on-host axis
 calculation for performance.

---
 Sources/TensorFlow/Operators/Basic.swift | 42 ++++++++++++++++--------
 1 file changed, 29 insertions(+), 13 deletions(-)

diff --git a/Sources/TensorFlow/Operators/Basic.swift b/Sources/TensorFlow/Operators/Basic.swift
index 08f4b35f4..ab68d0746 100644
--- a/Sources/TensorFlow/Operators/Basic.swift
+++ b/Sources/TensorFlow/Operators/Basic.swift
@@ -389,15 +389,13 @@ public extension Tensor {
 
 public extension Tensor where Scalar: Numeric {
     @inlinable
-    @differentiable(
-        wrt: self,
-        vjp: _vjpUnbroadcasted(toShape:) where Scalar: TensorFlowFloatingPoint)
+    @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
     func unbroadcasted(toShape otherShape: Tensor<Int32>) -> Tensor {
-        let rankDiff = (rankTensor - otherShape.scalarCountTensor).rankLifted()
-        let ones = Raw.fill(dims: rankDiff, value: Tensor<Int32>(1))
-        let paddedShape = Tensor<Int32>(concatenating: [ones, otherShape], alongAxis: 0)
-        let broadcastIndices = Tensor<Int32>(Raw.where_(paddedShape .!= shapeTensor))
-        return sum(squeezingAxes: broadcastIndices).reshaped(toShape: otherShape)
+        // TODO: Simplify this once differentiating control flow is supported.
+	    return unbroadcast(to: {
+	      precondition(otherShape.rank == 1)
+	      return TensorShape(otherShape.scalars.map(Int.init))
+	    }())
     }
 
     @inlinable
@@ -407,23 +405,41 @@ public extension Tensor where Scalar: Numeric {
     }
 
     @inlinable
-    @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
+    @differentiable(wrt: self, vjp: _vjpUnbroadcasted(to:) where Scalar: TensorFlowFloatingPoint)
     func unbroadcasted(to shape: TensorShape) -> Tensor {
-        return unbroadcasted(toShape: Tensor<Int32>({ shape.dimensions.map(Int32.init) }()))
+        let dimensions = self.shape.dimensions
+	    var otherDimensions = shape.dimensions
+	    let rankDifference = dimensions.count - otherDimensions.count
+	    precondition(rankDifference >= 0, """
+	        The rank of 'self' must be greater than or equal to the number of \
+	        dimensions in the destination shape
+	        """)
+	    if rankDifference > 0 {
+            otherDimensions.insert(contentsOf: repeatElement(1, count: rankDifference), at: 0)
+	    }
+	    assert(dimensions.count == otherDimensions.count)
+	    var axes: [Int] = []
+	    axes.reserveCapacity(dimensions.count)
+	    for (i, (dim, otherDim)) in zip(dimensions, otherDimensions).enumerated() {
+	        if dim == otherDim { continue }
+	        if otherDim == 1 { axes.append(i); continue }
+	        preconditionFailure("Cannot unbroadcast \(self.shape) to \(shape)")
+	    }
+	    return sum(alongAxes: axes).reshaped(to: shape)
     }
 }
 
 extension Tensor where Scalar: TensorFlowFloatingPoint {
     @inlinable
     func _vjpBroadcasted(toShape shape: Tensor<Int32>) -> (Tensor, (Tensor) -> Tensor) {
-        return (broadcasted(toShape: shape), { [originalShape = self.shapeTensor] v in
+        return (broadcasted(toShape: shape), { [originalShape = shapeTensor] v in
             v.unbroadcasted(toShape: originalShape)
         })
     }
 
     @inlinable
-    func _vjpUnbroadcasted(toShape shape: Tensor<Int32>) -> (Tensor, (Tensor) -> Tensor) {
-        return (unbroadcasted(toShape: shape), { [originalShape = self.shapeTensor] v in
+    func _vjpUnbroadcasted(to shape: TensorShape) -> (Tensor, (Tensor) -> Tensor) {
+        return (unbroadcasted(to: shape), { [originalShape = shapeTensor] v in
             v.broadcasted(toShape: originalShape)
         })
     }

From dff19ec403da225ee3cba683616b41f4112db771 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Wed, 22 May 2019 11:45:08 -0400
Subject: [PATCH 38/55] [TF] Further cleanup of CompilerRuntime and friends.

---
 Sources/TensorFlow/Core/Execution.swift | 26 ----------
 Sources/TensorFlow/Core/Runtime.swift   | 69 +------------------------
 2 files changed, 1 insertion(+), 94 deletions(-)

diff --git a/Sources/TensorFlow/Core/Execution.swift b/Sources/TensorFlow/Core/Execution.swift
index 679a27543..ae4e5d993 100644
--- a/Sources/TensorFlow/Core/Execution.swift
+++ b/Sources/TensorFlow/Core/Execution.swift
@@ -12,38 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// If `serverAddress` is nil, use local session (good for forge testing).
-//
-// FIXME: We need transparent here because deabstraction isn't inlining this function.  We need to 
-// inline if a callee contains tensor ops, not only if it takes and returns a TensorFlow value.
-@_transparent
-@available(*, deprecated)
-public func enableTPU(serverAddress: String? = nil, infeed: Bool = true) {
-    _RuntimeConfig.executionMode = .tpu
-    if let serverAddress = serverAddress {
-        _RuntimeConfig.session = .remote(serverDef: serverAddress)
-    }
-}
-
-// FIXME: Extend the interface to support multiple GPU devices, and unify it with enableTPU() above.
-@_transparent
-@available(*, deprecated)
-public func enableGPU() {
-}
-
-@_transparent
-@available(*, deprecated)
-public func enableCPU() {
-}
-
 /// A TensorFlow device kind.
 public enum DeviceKind {
     /// The CPU device kind.
     case cpu
     /// The GPU device kind.
     case gpu
-    /// The TPU device kind.
-    case tpu
 }
 
 /// Executes a closure, making TensorFlow operations run on a specific kind of device.
diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index 21d0c6bc6..47ecbc69f 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -36,26 +36,6 @@ import Glibc
 #endif
 import CTensorFlow
 
-// @_frozen // SR-9739
-public enum _ExecutionMode : Equatable {
-  /// CPU or GPU execution.
-  case auto
-  /// TPU execution.
-  // TODO: assess if we can pass this bit of info from compiler settings (when
-  // enableTPU() is called), and avoid having this additional runtime bit.
-  case tpu
-  /// XLA jit-compilation backend (will use GPU when available, and otherwise
-  /// CPU).
-  case xla
-
-  public var isTPU: Bool {
-    switch self {
-    case .tpu: return true
-    default: return false
-    }
-  }
-}
-
 /// TraceContext contains the state needed to build a trace graph function
 /// (TF_Function). As eager ops are executed in tracing mode, their
 /// corresponding nodes are added to the trace graph (via
@@ -453,10 +433,6 @@ public enum _RuntimeConfig {
   /// tensor program in this process.
   static public var tensorFlowRuntimeInitialized = false
 
-  /// For CPU and GPU execution without XLA, use the auto mode. For XLA and/or
-  /// TPU execution, set the enum value accordingly.
-  static public var executionMode: _ExecutionMode = .auto
-
   /// When true, let TensorFlow GPU memory allocation start small and grow as
   /// needed. Otherwise, The entire GPU memory region is pre-allocated.
   static public var gpuMemoryAllowGrowth = true
@@ -514,12 +490,6 @@ private func configureRuntimeFromEnvironment() {
     debugLog("Setting TF logging verbose level to \(verboseLevel) from env.")
   }
 
-  if let value = getenv("SWIFT_TENSORFLOW_USE_TPU_INFEED"),
-    String(cString: value).lowercased() == "true" {
-      _RuntimeConfig.executionMode = .tpu
-      debugLog("Setting TPU execution with infeed from env.")
-  }
-
   if let value = getenv("SWIFT_TENSORFLOW_SERVER_ADDRESS") {
     let address = String(cString: value)
     debugLog("Env var SWIFT_TENSORFLOW_SERVER_ADDRESS has value \(address).")
@@ -572,23 +542,6 @@ private func configureRuntimeFromEnvironment() {
   }
 }
 
-/// Initialize the TPU system.
-/// - Note: This should be called only once.
-/// - Precondition: The given session must contain the given graph.
-// TODO(b/77572335): Reassess how to reset TPU after execution error.
-private func initializeTPU(withSession session: CTFSession, graph: CTFGraph,
-                           status: CTFStatus) {
-  debugLog("Initializing TPU.")
-  let configOp = TF_GraphOperationByName(graph, "ConfigureDistributedTPU")
-  internalConsistencyCheck(configOp != nil)
-  var configNode = TF_Output(oper: configOp, index: 0)
-  var dummyOutput: CTensor?
-  TF_SessionRun(session, nil, nil, nil, 0, &configNode, &dummyOutput, 1, nil,
-                0, nil, status)
-  checkOk(status)
-  TF_DeleteTensor(dummyOutput)
-}
-
 /// The host of any tensor computation.
 @_fixed_layout
 public final class _ExecutionContext {
@@ -603,9 +556,6 @@ public final class _ExecutionContext {
   /// Only set when there is some usable GPU.
   fileprivate let gpuDeviceNamePrefix: String?
 
-  /// Only set when there is some usable TPU.
-  fileprivate let tpuDeviceNamePrefix: String?
-
   /// The buffer storing a serialized TensorFlow config proto.
   public let tensorFlowConfig: UnsafeMutablePointer<TF_Buffer>
 
@@ -649,7 +599,7 @@ public final class _ExecutionContext {
       debugLog("Allowing growth for GPU memory allocator.")
     }
     self.tensorFlowConfig = TF_CreateConfig(
-      _RuntimeConfig.executionMode == .xla ? 1 : 0,
+      /* enable_xla_compilation */ 0,
       _RuntimeConfig.gpuMemoryAllowGrowth ? 1 : 0,
       _RuntimeConfig.cpuDeviceCount)
     TFE_ContextOptionsSetConfig(opts,
@@ -676,9 +626,6 @@ public final class _ExecutionContext {
     }
 
     // Initialize GPU device.
-    // While the code here is only needed when _RuntimeConfig.executionMode is
-    // set to .gpu, running it in all code paths helps keep things simple
-    // (e.g. so that the cpuDeviceNamePrefix property is always set.)
     let devices = TFE_ContextListDevices(eagerContext, status)
     checkOk(status)
     defer { TF_DeleteDeviceList(devices!) }
@@ -689,7 +636,6 @@ public final class _ExecutionContext {
     debugLog("There are \(deviceCount) devices.")
     var foundCPU = false
     var gpuCount = 0
-    var tpuCount = 0
     for deviceId in 0..<deviceCount {
       let cDeviceName = TF_DeviceListName(devices, deviceId, status)
       checkOk(status)
@@ -706,9 +652,6 @@ public final class _ExecutionContext {
       if deviceType == "GPU" {
         gpuCount += 1
       }
-      if deviceType == "TPU" {
-        tpuCount += 1
-      }
     }
     guard foundCPU else {
       fatalError("CPU should always be an available device.")
@@ -722,14 +665,6 @@ public final class _ExecutionContext {
       self.gpuDeviceNamePrefix = nil
     }
 
-    if tpuCount > 0 {
-      // According to server def generated when you set
-      // SWIFT_TENSORFLOW_SERVER_ADDRESS, the TPUs will all be on task 1.
-      self.tpuDeviceNamePrefix = "/job:localhost/replica:0/task:1/device:TPU:"
-    } else {
-      self.tpuDeviceNamePrefix = nil
-    }
-
     // Initialize the mutex.
     pthread_mutex_init(&mutex, nil)
   }
@@ -1072,8 +1007,6 @@ internal extension _ExecutionContext {
         return "\(cpuDeviceNamePrefix)\(index)"
       case .gpu:
         return "\(gpuDeviceNamePrefix!)\(index)"
-      case .tpu:
-        return "\(tpuDeviceNamePrefix!)\(index)"
       }
     }
     return nil

From ea040acefeed26ccd412238a7facaf776ced6642 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Wed, 22 May 2019 11:47:22 -0400
Subject: [PATCH 39/55] [TF-518] Set up infrastructure to connect to TPU on top
 of eager execution.

---
 Sources/TensorFlow/Core/Execution.swift |  2 ++
 Sources/TensorFlow/Core/Runtime.swift   | 35 ++++++++++++++++++++++++-
 2 files changed, 36 insertions(+), 1 deletion(-)

diff --git a/Sources/TensorFlow/Core/Execution.swift b/Sources/TensorFlow/Core/Execution.swift
index ae4e5d993..1a610ce54 100644
--- a/Sources/TensorFlow/Core/Execution.swift
+++ b/Sources/TensorFlow/Core/Execution.swift
@@ -18,6 +18,8 @@ public enum DeviceKind {
     case cpu
     /// The GPU device kind.
     case gpu
+    /// The TPU device kind.
+    case tpu
 }
 
 /// Executes a closure, making TensorFlow operations run on a specific kind of device.
diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index 47ecbc69f..78a9a32ff 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -524,6 +524,17 @@ private func configureRuntimeFromEnvironment() {
         protocol: "\(`protocol`)"
         """)
       debugLog("Setting TF server address to \(address) from env.")
+
+      // At the moment, without TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC=1,
+      // running on TPUs freezes. Therefore, we set this environment variable
+      // to 1 unless it's set explicitly.
+      if let value = getenv("TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC") {
+        debugLog("TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC already set:")
+        debugLog(String(cString: value))
+      } else {
+        setenv("TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC", "1", /*override*/ 0)
+        debugLog("Setting TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC to 1")
+      }
     }
   }
 
@@ -556,6 +567,9 @@ public final class _ExecutionContext {
   /// Only set when there is some usable GPU.
   fileprivate let gpuDeviceNamePrefix: String?
 
+  /// Only set when there is some usable GPU.
+	fileprivate let tpuDeviceNamePrefix: String?
+
   /// The buffer storing a serialized TensorFlow config proto.
   public let tensorFlowConfig: UnsafeMutablePointer<TF_Buffer>
 
@@ -636,6 +650,7 @@ public final class _ExecutionContext {
     debugLog("There are \(deviceCount) devices.")
     var foundCPU = false
     var gpuCount = 0
+    var tpuCount = 0
     for deviceId in 0..<deviceCount {
       let cDeviceName = TF_DeviceListName(devices, deviceId, status)
       checkOk(status)
@@ -652,6 +667,9 @@ public final class _ExecutionContext {
       if deviceType == "GPU" {
         gpuCount += 1
       }
+      if deviceType == "TPU" {
+        tpuCount += 1
+      }
     }
     guard foundCPU else {
       fatalError("CPU should always be an available device.")
@@ -665,6 +683,14 @@ public final class _ExecutionContext {
       self.gpuDeviceNamePrefix = nil
     }
 
+    if tpuCount > 0 {
+      // According to server def generated when you set
+      // SWIFT_TENSORFLOW_SERVER_ADDRESS, the TPUs will all be on task 1.
+      self.tpuDeviceNamePrefix = "/job:localhost/replica:0/task:1/device:TPU:"
+    } else {
+      self.tpuDeviceNamePrefix = nil
+    }
+
     // Initialize the mutex.
     pthread_mutex_init(&mutex, nil)
   }
@@ -1007,6 +1033,8 @@ internal extension _ExecutionContext {
         return "\(cpuDeviceNamePrefix)\(index)"
       case .gpu:
         return "\(gpuDeviceNamePrefix!)\(index)"
+      case .tpu:
+        return "\(tpuDeviceNamePrefix!)\(index)"
       }
     }
     return nil
@@ -1083,7 +1111,12 @@ internal func _TFCEagerExecute(_ op: CTFEOp,
                                _ status: CTFStatus) {
   if _RuntimeConfig.printsDebugLog {
     debugLog("Calling _TFCEagerExecute() over: ")
-    TFE_OpPrintDebugString(op)
+    if let value = getenv("TF_CPP_MIN_LOG_LEVEL"),
+      String(cString: value) == "0" {
+      TFE_OpPrintDebugString(op)
+    } else {
+      debugLog("[Run with TF_CPP_MIN_LOG_LEVEL=0 to have TFEOps printed out]")
+    }
   }
   if let traceContext = _RuntimeConfig.traceState.context {
     // convert this eager op into a trace graph node

From 70ba68f90d3718cba7874e3c86fdc27502c5b91d Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Wed, 22 May 2019 14:19:09 -0400
Subject: [PATCH 40/55] Bug fixes.

---
 Sources/TensorFlow/Core/Runtime.swift    | 3 ---
 Sources/TensorFlow/Operators/Basic.swift | 3 +--
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index 78a9a32ff..7f74a1615 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -606,9 +606,6 @@ public final class _ExecutionContext {
     }
 
     // Create TF config object.
-    if _RuntimeConfig.executionMode == .xla {
-      debugLog("Enable XLA execution.")
-    }
     if _RuntimeConfig.gpuMemoryAllowGrowth {
       debugLog("Allowing growth for GPU memory allocator.")
     }
diff --git a/Sources/TensorFlow/Operators/Basic.swift b/Sources/TensorFlow/Operators/Basic.swift
index ab68d0746..77202a6c1 100644
--- a/Sources/TensorFlow/Operators/Basic.swift
+++ b/Sources/TensorFlow/Operators/Basic.swift
@@ -381,7 +381,6 @@ public extension Tensor {
     }
 
     @inlinable
-    @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
     static func .= (lhs: inout Tensor, rhs: Tensor) {
         lhs = rhs.broadcasted(like: lhs)
     }
@@ -392,7 +391,7 @@ public extension Tensor where Scalar: Numeric {
     @differentiable(wrt: self where Scalar: TensorFlowFloatingPoint)
     func unbroadcasted(toShape otherShape: Tensor<Int32>) -> Tensor {
         // TODO: Simplify this once differentiating control flow is supported.
-	    return unbroadcast(to: {
+	    return unbroadcasted(to: {
 	      precondition(otherShape.rank == 1)
 	      return TensorShape(otherShape.scalars.map(Int.init))
 	    }())

From 5c758d21dca9801d9e55d0419d1f4f5f35f17fbb Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 26 May 2019 14:10:56 -0500
Subject: [PATCH 41/55] Move TensorGroup out of TensorFlow and into the
 standard library so that TensorFlow is no longer a special module.

---
 Sources/TensorFlow/Core/DataTypes.swift   | 16 +++-----
 Sources/TensorFlow/Core/TensorGroup.swift | 45 -----------------------
 2 files changed, 6 insertions(+), 55 deletions(-)

diff --git a/Sources/TensorFlow/Core/DataTypes.swift b/Sources/TensorFlow/Core/DataTypes.swift
index 622db5f7a..2d239e3f8 100644
--- a/Sources/TensorFlow/Core/DataTypes.swift
+++ b/Sources/TensorFlow/Core/DataTypes.swift
@@ -14,18 +14,14 @@
 
 import CTensorFlow
 
-/// A TensorFlow dynamic type value that can be created from types that conform to 
-/// `TensorFlowScalar`.
-// This simply wraps a `TF_DataType` and allows user code to handle `TF_DataType` without importing
-// CTensorFlow, which pollutes the namespace with TensorFlow C API declarations.
-@_fixed_layout
-public struct TensorDataType {
-    public var _cDataType: TF_DataType
+public extension TensorDataType {
+    public var _cDataType: TF_DataType {
+        return TF_DataType(rawValue: _internalStorageType)
+    }
 
-    @inlinable
     public init(_ cDataType: TF_DataType) {
-        self._cDataType = cDataType
-    }
+	    self.init(rawValue: cDataType.rawValue)
+	}
 }
 
 @usableFromInline
diff --git a/Sources/TensorFlow/Core/TensorGroup.swift b/Sources/TensorFlow/Core/TensorGroup.swift
index bb6958136..4cca0a49c 100644
--- a/Sources/TensorFlow/Core/TensorGroup.swift
+++ b/Sources/TensorFlow/Core/TensorGroup.swift
@@ -14,51 +14,6 @@
 
 import CTensorFlow
 
-/// A protocol representing types that can be mapped to `Array<CTensorHandle>`.
-///
-/// This protocol is defined separately from `TensorGroup` in order for the number of tensors to be 
-/// determined at runtime. For example, `[Tensor<Float>]` may have an unknown number of elements at 
-/// compile time.
-///
-/// This protocol can be derived automatically for structs whose stored properties all conform to 
-/// the `TensorGroup` protocol. It cannot be derived automatically for structs whose properties all 
-/// conform to `TensorArrayProtocol` due to the constructor requirement (i.e., in such cases it
-/// would be impossible to know how to break down `count` among the stored properties).
-public protocol TensorArrayProtocol {
-    /// Writes the tensor handles to `address`, which must be allocated with enough capacity to hold
-    /// `_tensorHandleCount` handles. The tensor handles written to `address` are borrowed: this
-    /// container still owns them.
-    func _unpackTensorHandles(into address: UnsafeMutablePointer<CTensorHandle>?)
-
-    var _tensorHandleCount: Int32 { get }
-    var _typeList: [TensorDataType] { get }
-
-    init(_owning tensorHandles: UnsafePointer<CTensorHandle>?, count: Int)
-}
-
-/// A protocol representing types that can be mapped to and from `Array<CTensorHandle>`.
-///
-/// When a `TensorGroup` is used as an argument to a tensor operation, it is passed as an argument 
-/// list whose elements are the tensor fields of the type.
-///
-/// When a `TensorGroup` is returned as a result of a tensor operation, it is initialized with its
-/// tensor fields set to the tensor operation's tensor results.
-public protocol TensorGroup: TensorArrayProtocol {
-    /// The types of the tensor stored properties in this type.
-    static var _typeList: [TensorDataType] { get }
-
-    /// An array of `nil`s with the same number of elements as `_outputTypeList`. The `nil`
-    /// represents unknown shape.
-    // TODO: This is a protocol requirement so that conformances can provide custom const-evaluable 
-    // implementations. When the const-evaluator is powerful enough to evaluate the default
-    // implementation, remove this requirement.
-    static var _unknownShapeList: [TensorShape?] { get }
-
-    /// Initializes a value of this type, taking ownership of the `_tensorHandleCount` tensors
-    /// starting at address `tensorHandles`.
-    init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)
-}
-
 public extension TensorGroup {
     /// The number of tensor fields in this type.
     static var _tensorHandleCount: Int32 { return Int32(Self._typeList.count) }

From 45d868ddae860607c08b53a4bdb45b54bace6e5b Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 26 May 2019 14:18:49 -0500
Subject: [PATCH 42/55] Convert _AnyTensorHandle to a protocol and add
 'TFETensorHandle' type.

---
 Sources/TensorFlow/Core/Runtime.swift      |  32 +------
 Sources/TensorFlow/Core/TensorGroup.swift  |   6 +-
 Sources/TensorFlow/Core/TensorHandle.swift | 103 ++++++++++++---------
 3 files changed, 63 insertions(+), 78 deletions(-)

diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index 7f74a1615..85066c409 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -874,12 +874,12 @@ private func _graphInternal<State : _TensorArrayProtocolEnhanced,
     debugLog("Getting input state tensor handles.")
     let inputStateTensorHandles =  oldState.cTensorHandles
     var inputTensors = inputStateTensorHandles.map {
-      _TFCCreateTensorHandleFromC($0)
+      TFETensorHandle(_owning: $0)
     }
     debugLog("Getting input data tensor handles.")
     let inputDataTensorHandles =  data.cTensorHandles
     inputTensors.append(contentsOf: inputDataTensorHandles.map {
-      _TFCCreateTensorHandleFromC($0)
+      TFETensorHandle(_owning: $0)
     })
 
     debugLog("Executing trace graph function.")
@@ -980,7 +980,7 @@ public func _graph<In : TensorGroup, Out : TensorGroup>(
     debugLog("Getting input state tensor handles.")
     let inputStateTensorHandles =  input.cTensorHandles
     let inputTensors = inputStateTensorHandles.map {
-      _TFCCreateTensorHandleFromC($0)
+      TFETensorHandle(_owning: $0)
     }
     debugLog("Executing trace graph function.")
     let returnValues = traceContext.execute(
@@ -1189,32 +1189,6 @@ func _TFCOpAddInputFromAnyTensors(
   }
 }
 
-@inlinable
-@_silgen_name("_swift_tfc_CreateTensorHandleFromC")
-public func _TFCCreateTensorHandleFromC(
-  _ cHandle: CTensorHandle
-) -> _AnyTensorHandle {
-  let dtype = TFE_TensorHandleDataType(cHandle)
-  switch dtype {
-  case TF_BFLOAT16: return TensorHandle<BFloat16>(_owning: cHandle)
-  case TF_UINT8: return TensorHandle<UInt8>(_owning: cHandle)
-  case TF_INT8: return TensorHandle<Int8>(_owning: cHandle)
-  case TF_UINT16: return TensorHandle<UInt16>(_owning: cHandle)
-  case TF_INT16: return TensorHandle<Int16>(_owning: cHandle)
-  case TF_UINT32: return TensorHandle<UInt32>(_owning: cHandle)
-  case TF_INT32: return TensorHandle<Int32>(_owning: cHandle)
-  case TF_UINT64: return TensorHandle<UInt64>(_owning: cHandle)
-  case TF_INT64: return TensorHandle<Int64>(_owning: cHandle)
-  case TF_FLOAT: return TensorHandle<Float>(_owning: cHandle)
-  case TF_DOUBLE: return TensorHandle<Double>(_owning: cHandle)
-  case TF_BOOL: return TensorHandle<Bool>(_owning: cHandle)
-  case TF_STRING: return TensorHandle<String>(_owning: cHandle)
-  case TF_RESOURCE: return ResourceHandle(owning: cHandle)
-  case TF_VARIANT: return VariantHandle(owning: cHandle)
-  default: fatalError("Unsupported dtype \(dtype)")
-  }
-}
-
 // _TFCOpSetAttr*Array functions are wrappers around TFE_OpSetAttr*List
 // functions. The wrappers handle converting the Swift Stdlib Array<T> values
 // into buffers that TFE_OpSetAttr*List functions can read.
diff --git a/Sources/TensorFlow/Core/TensorGroup.swift b/Sources/TensorFlow/Core/TensorGroup.swift
index 4cca0a49c..f06809bda 100644
--- a/Sources/TensorFlow/Core/TensorGroup.swift
+++ b/Sources/TensorFlow/Core/TensorGroup.swift
@@ -53,7 +53,7 @@ extension TensorHandle: TensorGroup {
         address!.initialize(to: _cTensorHandle)
     }
 
-    public convenience init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
+    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
         self.init(_owning: tensorHandles!.pointee)
     }
 }
@@ -73,7 +73,7 @@ extension ResourceHandle: TensorGroup {
         address!.initialize(to: _cTensorHandle)
     }
 
-    public convenience init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
+    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
         self.init(owning: tensorHandles!.pointee)
     }
 }
@@ -93,7 +93,7 @@ extension VariantHandle: TensorGroup {
         address!.initialize(to: _cTensorHandle)
     }
 
-    public convenience init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
+    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?) {
         self.init(owning: tensorHandles!.pointee)
     }
 }
diff --git a/Sources/TensorFlow/Core/TensorHandle.swift b/Sources/TensorFlow/Core/TensorHandle.swift
index 267da89e5..c98acc294 100644
--- a/Sources/TensorFlow/Core/TensorHandle.swift
+++ b/Sources/TensorFlow/Core/TensorHandle.swift
@@ -14,35 +14,56 @@
 
 import CTensorFlow
 
-/// `_AnyTensorHandle` is the scalar-agnostic base type for `TensorHandle`, used specifically for
-/// low-level, type-erased passings of Swift-level tensor handles in the compiler.
-@_fixed_layout // required because the compiler accesses _cTensorHandle directly.
-public class _AnyTensorHandle {
+/// This protocol abstracts the underlying representation of a tensor. Any type
+/// that conforms to this protocol can be used as a `TensorHandle` in the
+/// `TensorFlow` library, as it much provide a way to convert the underlying tensor
+/// handle into a `ConcreteTensorHandle`, which wraps a `TFE_TensorHandle *`
+/// TODO(https://bugs.swift.org/browse/TF-527): This is defined as a class-bound
+// protocol to workaround bug TF-527. When it is fixed, we should remove `: class`.
+public protocol _AnyTensorHandle: class {
+    var _tfeTensorHandle: TFETensorHandle { get }
+}
+
+extension _AnyTensorHandle {
     /// The underlying `TFE_TensorHandle *`.
-    ///
-    /// - Note: The compiler knows that `_AnyTensorHandle` has a single stored property, and assumes 
-    ///   that this is it. Changing the design of `TensorHandle` will require tweaking the compiler.
-    public let _cTensorHandle: CTensorHandle
-
-    /// Private initializer from a `CTensorHandle`. Should only be called from
-    /// `TensorHandle<Scalar>.init`.
-    fileprivate init(base: CTensorHandle) {
-        self._cTensorHandle = base
+    public let _cTensorHandle: CTensorHandle {
+        return _tfeTensorHandle._cTensorHandle
     }
 }
 
+/// Class wrapping a C pointer to a TensorHandle.  This class owns the
+/// TensorHandle and is responsible for destroying it.
+public class TFETensorHandle: _AnyTensorHandle {
+	public let _cTensorHandle: CTensorHandle
+
+    public var _tfeTensorHandle: TFETensorHandle { return self }
+
+    public init(_owning base: CTensorHandle) {
+	    self._cTensorHandle = base
+	}
+
+    deinit {
+	    debugLog("De-initializing TensorHandle.")
+	    TFE_DeleteTensorHandle(_cTensorHandle)
+	    debugLog("Returning from deinit of TensorHandle.")
+	}
+}
+
+
+/// `TensorHandle` is the type used by ops. It includes a `Scalar` type, which
+/// compiler internals can use to determine the datatypes of parameters when
+/// they are extracted into a tensor program.
+public struct TensorHandle<Scalar> where Scalar: _TensorFlowDataTypeCompatible {
+    let handle: _AnyTensorHandle
+	
+	public var _cTensorHandle: CTensorHandle { handle._cTensorHandle }
 
-/// `TensorHandle` is the type used by ops. It includes a `Scalar` type, which compiler internals 
-/// use to determine the datatypes of parameters when they are extracted into a tensor program.
-@_fixed_layout // required because the compiler accesses _cTensorHandle directly.
-public final class TensorHandle<Scalar>: _AnyTensorHandle
-    where Scalar: _TensorFlowDataTypeCompatible {
     public init(_owning cTensorHandle: CTensorHandle) {
-        super.init(base: cTensorHandle)
+        self.handle = TFETensorHandle(_owning: cTensorHandle)
     }
 
     @usableFromInline
-    internal convenience init(copyingFromCTensor cTensor: CTensor) {
+    init(copyingFromCTensor cTensor: CTensor) {
         let status = TF_NewStatus()
         let cTensorHandle = TFE_NewTensorHandle(cTensor, status)
         checkOk(status)
@@ -50,12 +71,6 @@ public final class TensorHandle<Scalar>: _AnyTensorHandle
         TF_DeleteStatus(status)
     }
 
-    deinit {
-        debugLog("De-initializing TensorHandle.")
-        TFE_DeleteTensorHandle(_cTensorHandle)
-        debugLog("Returning from deinit of TensorHandle.")
-    }
-
     /// Create a `TensorHandle` with a closure that initializes the underlying buffer.
     ///
     /// Users initializing `TensorHandle`s with non-`String` scalars should use the
@@ -65,7 +80,7 @@ public final class TensorHandle<Scalar>: _AnyTensorHandle
     /// `bufferInitializer` receives a buffer with exactly `byteCount` bytes of capacity.
     /// `bufferInitializer` must initialize the entire buffer.
     @inlinable
-    public convenience init(
+    init(
         shape: [Int],
         byteCount: Int,
         bufferInitializer: (UnsafeMutableRawPointer) -> Void
@@ -94,7 +109,7 @@ extension TensorHandle where Scalar: TensorFlowScalar {
     /// tensor with shape `shape`. `scalarsInitializer` must initialize the entire buffer, with
     /// contiguous scalars in row-major order.
     @inlinable
-    public convenience init(
+    public init(
         shape: [Int],
         scalarsInitializer: (UnsafeMutablePointer<Scalar>) -> Void
     ) {
@@ -120,30 +135,26 @@ internal extension TensorHandle {
     }
 }
 
-/// `ResourceHandle` is the type used by ops to represent TensorFlow "resource" values.
-public final class ResourceHandle: _AnyTensorHandle {
+public struct ResourceHandle {
+    let handle: _AnyTensorHandle
+
+    @usableFromInline
+    var _cTensorHandle: CTensorHandle { handle._cTensorHandle }
+    
     @usableFromInline
     init(owning cTensorHandle: CTensorHandle) {
-        super.init(base: cTensorHandle)
-    }
-
-    deinit {
-        debugLog("De-initializing TensorHandle.")
-        TFE_DeleteTensorHandle(_cTensorHandle)
-        debugLog("Returning from deinit of ResourceHandle.")
+        self.handle = TFETensorHandle(_owning: cTensorHandle)
     }
 }
 
-/// `VariantHandle` is the type used by ops to represent TensorFlow "variant" values.
-public final class VariantHandle: _AnyTensorHandle {
+public struct VariantHandle {
+    let handle: _AnyTensorHandle
+
+    @usableFromInline
+    var _cTensorHandle: CTensorHandle { handle._cTensorHandle }
+    
     @usableFromInline
     init(owning cTensorHandle: CTensorHandle) {
-        super.init(base: cTensorHandle)
-    }
-
-    deinit {
-        debugLog("De-initializing TensorHandle.")
-        TFE_DeleteTensorHandle(_cTensorHandle)
-        debugLog("Returning from deinit of VariantHandle.")
+        self.handle = TFETensorHandle(_owning: cTensorHandle)
     }
 }

From 6021eb3c1a6affb58a6e292d143a1cb4c7b62517 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 26 May 2019 14:23:49 -0500
Subject: [PATCH 43/55] [TF-528] Introduce withDevice(named: "...") { ... }.

---
 Sources/TensorFlow/Core/Execution.swift |  32 ++++---
 Sources/TensorFlow/Core/Runtime.swift   | 120 ++++++++++++------------
 2 files changed, 81 insertions(+), 71 deletions(-)

diff --git a/Sources/TensorFlow/Core/Execution.swift b/Sources/TensorFlow/Core/Execution.swift
index 1a610ce54..9ef66a3ad 100644
--- a/Sources/TensorFlow/Core/Execution.swift
+++ b/Sources/TensorFlow/Core/Execution.swift
@@ -29,18 +29,30 @@ public enum DeviceKind {
 ///   - index: The device to run the ops on.
 ///   - body: A closure whose TensorFlow operations are to be executed on the
 ///     specified kind of device.
-// Use `@inline(never)` to ensure correctness in scoped device placement. See
-// https://bugs.swift.org/browse/SR-9535 for more context.
-@inline(never)
 public func withDevice<R>(
     _ kind: DeviceKind,
     _ index: UInt = 0,
     perform body: () throws -> R
 ) rethrows -> R {
-    _ThreadLocalState.value.pushDevice((kind, index))
-    let result = try body()
-    _ThreadLocalState.value.popDevice()
-    return result
+    return try _ExecutionContext.global.withDevice(kind, index, perform: body)
+}
+
+/// Executes a closure, making TensorFlow operations run on a device with
+/// a specific name.
+///
+/// - Parameters:
+///   - name: Device name.
+///   - body: A closure whose TensorFlow operations are to be executed on the
+///     specified kind of device.
+///
+/// Some examples of device names:
+///   - "/device:CPU:0": The CPU of your machine.
+///   - "/GPU:0": Short-hand notation for the first GPU of your machine that
+///     is visible to TensorFlow
+///   - "/job:localhost/replica:0/task:0/device:GPU:1": Fully qualified name of
+///     the second GPU of your machine that is visible to TensorFlow.
+public func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R {
+    return try _ExecutionContext.global.withDevice(named: name, perform: body)
 }
 
 /// Executes a closure, allowing TensorFlow to place TensorFlow operations on any device. This
@@ -49,10 +61,6 @@ public func withDevice<R>(
 /// - Parameters:
 ///   - body: A closure whose TensorFlow operations are to be executed on the specified kind of 
 ///     device.
-@inline(never)
 public func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R {
-    _ThreadLocalState.value.pushDevice(nil)
-    let result = try body()
-    _ThreadLocalState.value.popDevice()
-    return result
+    return try _ExecutionContext.global.withDefaultDevice(perform: body)
 }
diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index 85066c409..4b428f447 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -559,16 +559,10 @@ public final class _ExecutionContext {
   /// Global context storing all available devices, loaded functions, etc.
   public static let global: _ExecutionContext = _ExecutionContext()
 
-  // TODO: When we use remote session, we need to set cpu device to a local
-  // device.  There is no C API yet to find the local device. So, we are
-  // hard-coding the value for now.
-  fileprivate let cpuDeviceNamePrefix = "/job:localhost/replica:0/task:0/device:CPU:"
-
-  /// Only set when there is some usable GPU.
-  fileprivate let gpuDeviceNamePrefix: String?
-
-  /// Only set when there is some usable GPU.
-	fileprivate let tpuDeviceNamePrefix: String?
+  /// List of devices available to this execution context.
+  /// Devices are represented by their names in TensorFlow notation.
+  /// See documentation for `withDevice(named:perform:)` to learn about device names.
+  private var deviceNames: [String] = []
 
   /// The buffer storing a serialized TensorFlow config proto.
   public let tensorFlowConfig: UnsafeMutablePointer<TF_Buffer>
@@ -636,18 +630,12 @@ public final class _ExecutionContext {
       TF_DeleteBuffer(serverDef)
     }
 
-    // Initialize GPU device.
     let devices = TFE_ContextListDevices(eagerContext, status)
     checkOk(status)
     defer { TF_DeleteDeviceList(devices!) }
 
-    // Sanity check and gather/log device info. When `gpuCount` > 0, set
-    // `self.gpuDeviceNamePrefix`. Likewise with `tpuCount`.
     let deviceCount = TF_DeviceListCount(devices!)
     debugLog("There are \(deviceCount) devices.")
-    var foundCPU = false
-    var gpuCount = 0
-    var tpuCount = 0
     for deviceId in 0..<deviceCount {
       let cDeviceName = TF_DeviceListName(devices, deviceId, status)
       checkOk(status)
@@ -655,29 +643,8 @@ public final class _ExecutionContext {
       let cDeviceType = TF_DeviceListType(devices, deviceId, status)
       checkOk(status)
       let deviceType = String(cString: cDeviceType!)
-      debugLog(
-        "Device \(deviceId) has type \(deviceType) and name \(deviceName)."
-      )
-      if deviceType == "CPU", deviceName.starts(with: cpuDeviceNamePrefix) {
-        foundCPU = true
-      }
-      if deviceType == "GPU" {
-        gpuCount += 1
-      }
-      if deviceType == "TPU" {
-        tpuCount += 1
-      }
-    }
-    guard foundCPU else {
-      fatalError("CPU should always be an available device.")
-    }
-    // We ignore the number of GPUs for now. It might be useful to cross check
-    // that against the number of GPUs that user intends to use (e.g. via the
-    // `withDevice` syntax).
-    if gpuCount > 0 {
-      self.gpuDeviceNamePrefix = "/job:localhost/replica:0/task:0/device:GPU:"
-    } else {
-      self.gpuDeviceNamePrefix = nil
+      debugLog("Device \(deviceId) has type \(deviceType) and name \(deviceName).")
+      deviceNames.append(deviceName)
     }
 
     if tpuCount > 0 {
@@ -688,7 +655,6 @@ public final class _ExecutionContext {
       self.tpuDeviceNamePrefix = nil
     }
 
-    // Initialize the mutex.
     pthread_mutex_init(&mutex, nil)
   }
 
@@ -1017,24 +983,53 @@ public func _tffunc<In : TensorGroup, Out : TensorGroup>(
   return traceContext.specializeTFFunction(with: [])
 }
 
-/// Returns a valid TF device string such as
-/// "/job:localhost/replica:0/task:0/device:CPU:0", which corresponds to the
-/// closest enclosing withDevice() construct.
-/// A return value of nil indicates the absence of withDevice().
 internal extension _ExecutionContext {
-  @usableFromInline
+  /// Returns a valid TensorFlow device name, which corresponds to the
+  /// closest enclosing call to one of the overloads of withDevice.
+  /// A return value of `nil` indicates the absence of a withDevice call on
+  /// the call stack or the presence of an immediately enclosing
+  /// `withDefaultDevice(perform)` call.
   var currentDeviceName: String? {
-    if let (kind, index) = _ThreadLocalState.value._currentDevice {
-      switch kind {
-      case .cpu:
-        return "\(cpuDeviceNamePrefix)\(index)"
-      case .gpu:
-        return "\(gpuDeviceNamePrefix!)\(index)"
-      case .tpu:
-        return "\(tpuDeviceNamePrefix!)\(index)"
-      }
+    return _ThreadLocalState.local._currentDevice
+  }
+
+  /// See documentation for the top-level `withDevice(_:_:perform)`.
+  func withDevice<R>(
+    _ kind: DeviceKind,
+    _ index: UInt = 0,
+    perform body: () throws -> R
+  ) rethrows -> R {
+    let name: String
+    switch kind {
+    case .cpu:
+      name = "/job:localhost/replica:0/task:0/device:CPU:\(index)"
+    case .gpu:
+      name = "/job:localhost/replica:0/task:0/device:GPU:\(index)"
+    case .tpu:
+      // According to server def generated when you set
+      // SWIFT_TENSORFLOW_SERVER_ADDRESS, the TPUs will all be on task 1.
+      name = "/job:localhost/replica:0/task:1/device:TPU:\(index)"
+    }
+    return try withDevice(named: name, perform: body)
+  }
+
+  /// See documentation for the top-level `withDevice(named:perform)`.
+  func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R {
+    guard deviceNames.contains(name) else {
+      fatalError("Device \(name) not found")
     }
-    return nil
+    _ThreadLocalState.local.pushDevice(name)
+    let result = try body()
+    _ThreadLocalState.local.popDevice()
+    return result
+  }
+
+  /// See documentation for the top-level `withDefaultDevice(perform)`.
+  func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R {
+    _ThreadLocalState.local.pushDevice(nil)
+    let result = try body()
+    _ThreadLocalState.local.popDevice()
+    return result
   }
 }
 
@@ -1236,9 +1231,16 @@ fileprivate func setAttrShapeList(
   }
 }
 
+/// Stack of devices that models nested calls to withDevice/withDefaultDevice.
+/// Devices are represented by their names in TensorFlow notation.
+/// See documentation for `withDevice(named:perform:)` to learn about device names.
+///
+/// All TensorFlow operations will be put on the topmost device on the stack.
+/// When the stack is empty or the topmost device is `nil`, that allows
+/// TensorFlow to place operations on any device that it sees fit.
 @usableFromInline
 class _ThreadLocalState {
-  var deviceScopes: [(kind: DeviceKind, index: UInt)?] = []
+  var deviceScopes: [String?] = []
 
   private static let key: pthread_key_t = {
     var key = pthread_key_t()
@@ -1252,12 +1254,12 @@ class _ThreadLocalState {
     return key
   }()
 
-  var _currentDevice: (DeviceKind, UInt)? {
+  var _currentDevice: String? {
     return deviceScopes.last ?? nil
   }
 
   @usableFromInline
-  func pushDevice(_ device: (DeviceKind, UInt)?) {
+  func pushDevice(_ device: String?) {
     deviceScopes.append(device)
   }
 
@@ -1267,7 +1269,7 @@ class _ThreadLocalState {
   }
 
   @usableFromInline
-  static var value: _ThreadLocalState {
+  static var local: _ThreadLocalState {
     if let state = pthread_getspecific(key) {
       return Unmanaged.fromOpaque(state).takeUnretainedValue()
     }

From 1063910130b7efccabb02a95f4bf9e27977da5bc Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 26 May 2019 14:25:49 -0500
Subject: [PATCH 44/55] Add makeOp function from tensoflow-swift-bindings.

---
 Sources/TensorFlow/Core/Runtime.swift | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index 4b428f447..3a53d3b73 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -668,6 +668,15 @@ public final class _ExecutionContext {
   }
 }
 
+extension _ExecutionContext {
+  // The execution mode is effectively encoded in the TensorOperation.
+  // We can use this to switch between different execution modes.
+  // TODO: Can we interop between modes?
+  public static func makeOp(_ name: String, _ nOutputs: Int) -> TFTensorOperation {
+    return TFE_Op(name, nOutputs)
+  }
+}
+
 // Elements in `outputs` can come from two sources:
 // a) Symbolic tensors produced by tensor ops, and added as trace graph nodes.
 // b) Concrete tensors produced by host code (e.g. Tensor(1.0)).

From d970a4b800c2dc0095de591e4c9471ead248d72a Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Sun, 26 May 2019 15:29:05 -0500
Subject: [PATCH 45/55] Removed some redundant code.

---
 Sources/TensorFlow/Core/Dataset.swift | 216 --------------------------
 1 file changed, 216 deletions(-)
 delete mode 100644 Sources/TensorFlow/Core/Dataset.swift

diff --git a/Sources/TensorFlow/Core/Dataset.swift b/Sources/TensorFlow/Core/Dataset.swift
deleted file mode 100644
index fdd4ae368..000000000
--- a/Sources/TensorFlow/Core/Dataset.swift
+++ /dev/null
@@ -1,216 +0,0 @@
-//===-- Dataset.swift -----------------------------------------*- swift -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-// The dataset API.
-//
-//===----------------------------------------------------------------------===//
-
-/// The default graph seed.
-///
-/// - Note: See TensorFlow's `python.framework.random_seed.DEFAULT_GRAPH_SEED`.
-@usableFromInline let _defaultGraphSeed: Int64 = 87654321
-
-/// Returns the local seeds an operation should use given an op-specific seed.
-///
-/// Given operation-specific seed, `seed`, this helper function returns two
-/// seeds derived from graph-level and op-level seeds. Many random operations
-/// internally use the two seeds to allow user to change the seed globally for a
-/// graph, or for only specific operations.
-///
-/// - Note: See TensorFlow's `python.framework.random_seed.get_seed`.
-///
-// TODO: There's no support for TF's "global seed" yet, so we always use the
-// default graph seed as the first seed. Need to investigate the best way to
-// model TF's "global seed".
-@usableFromInline @inline(__always)
-func _tensorSeeds(_ seed: Tensor<Int64>) -> (Tensor<Int64>, Tensor<Int64>) {
-  return (Tensor(_defaultGraphSeed), seed)
-}
-
-//===----------------------------------------------------------------------===//
-// Single value dataset
-//===----------------------------------------------------------------------===//
-
-/// Represents a potentially large set of elements.
-///
-/// A `Dataset` can be used to represent an input pipeline as a collection of
-/// element tensors.
-@_fixed_layout
-public struct Dataset<Element : TensorGroup> {
-  public let _handle: VariantHandle
-
-  @inlinable
-  public init(_handle: VariantHandle) {
-    self._handle = _handle
-  }
-}
-
-public extension Dataset {
-  @inlinable
-  init(randomSeed: Int64) {
-    let (seed1, seed2) = _tensorSeeds(Tensor(randomSeed))
-    self.init(_handle: Raw.experimentalRandomDataset(
-      seed: seed1,
-      seed2: seed2,
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList))
-  }
-}
-
-public extension Dataset {
-  /// Creates a dataset from a batch of elements as a tensor.
-  @inlinable
-  init(elements: Element) {
-    self.init(_handle: Raw.tensorSliceDataset(
-      components: [elements],
-      outputShapes: Element._unknownShapeList))
-  }
-}
-
-extension Dataset : Sequence {
-  public typealias Iterator = DatasetIterator<Element>
-
-  /// Returns an iterator over the elements of this dataset.
-  @inlinable
-  public func makeIterator() -> DatasetIterator<Element> {
-    let resource = Raw.anonymousIterator(
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList)
-    Raw.makeIterator(dataset: _handle, iterator: resource)
-    return DatasetIterator(_handle: resource)
-  }
-}
-
-public extension Dataset {
-  // Note that this Dataset API implementation uses an experimental tracing
-  // feature, which is not robust and does not have great diagnostics yet.
-  @inlinable
-  func map<ResultElement : TensorGroup>(
-    _ transform: (Element) -> ResultElement
-  ) -> Dataset<ResultElement> {
-    return Dataset<ResultElement>(_handle: Raw.mapDataset(
-      inputDataset: _handle,
-      otherArguments: Tensor<Int32>(0),
-      f: transform,
-      outputTypes: ResultElement._typeList,
-      outputShapes: ResultElement._unknownShapeList,
-      useInterOpParallelism: true,
-      preserveCardinality: false))
-  }
-
-  @inlinable
-  func map<ResultElement : TensorGroup>(
-    parallelCallCount: Int,
-    _ transform: (Element) -> ResultElement
-  ) -> Dataset<ResultElement> {
-    return Dataset<ResultElement>(_handle: Raw.parallelMapDataset(
-      inputDataset: _handle,
-      otherArguments: Tensor<Int32>(0),
-      numParallelCalls: Tensor<Int32>(Int32(parallelCallCount)),
-      f: transform,
-      outputTypes: ResultElement._typeList,
-      outputShapes: ResultElement._unknownShapeList,
-      useInterOpParallelism: true,
-      sloppy: false,
-      preserveCardinality: false))
-  }
-
-  @inlinable
-  func filter(
-    _ isIncluded: (Element) -> Tensor<Bool>
-  ) -> Dataset {
-    return Dataset(_handle: Raw.filterDataset(
-      inputDataset: _handle,
-      otherArguments: Tensor<Int32>(0),
-      predicate: isIncluded,
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList))
-  }
-}
-
-public extension Dataset {
-  @inlinable
-  func shuffled(
-    sampleCount: Int, randomSeed: Int64
-  ) -> Dataset {
-    let (seed1, seed2) = _tensorSeeds(Tensor(randomSeed))
-    return Dataset(_handle: Raw.shuffleDataset(
-      inputDataset: _handle,
-      bufferSize: Tensor(Int64(sampleCount)),
-      seed: seed1,
-      seed2: seed2,
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList))
-  }
-
-  @inlinable
-  func batched(_ batchSize: Int) -> Dataset {
-    return Dataset(_handle: Raw.batchDataset(
-      inputDataset: _handle,
-      batchSize: Tensor(Int64(batchSize)),
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList))
-  }
-}
-
-/// The type that allows iteration over a dataset's elements.
-@_fixed_layout
-public struct DatasetIterator<Element : TensorGroup> {
-  @usableFromInline let _handle: ResourceHandle
-
-  @usableFromInline
-  internal init(_handle: ResourceHandle) {
-    self._handle = _handle
-  }
-}
-
-extension DatasetIterator : IteratorProtocol {
-  /// Advances to the next element and returns it, or `nil` if no next element
-  /// exists.
-  @inlinable
-  public mutating func next() -> Element? {
-    let optional = Raw.iteratorGetNextAsOptional(
-      iterator: _handle,
-      outputTypes: Element._typeList,
-      outputShapes: Element._unknownShapeList)
-    guard Raw.optionalHasValue(optional: optional).scalarized() else {
-      return nil
-    }
-    return Raw.optionalGetValue(
-      optional: optional,
-      outputShapes: Element._unknownShapeList)
-  }
-}
-
-/// A 2-tuple-like struct that conforms to TensorGroup that represents a tuple 
-/// of 2 types conforming to TensorGroup.
-@_fixed_layout
-public struct Zip2TensorGroup<T : TensorGroup, U : TensorGroup> : TensorGroup {
-  public var first: T
-  public var second: U
-
-  public init(_ first: T, _ second: U) {
-    self.first = first
-    self.second = second
-  }
-}
-
-@inlinable
-public func zip<T : TensorGroup, U : TensorGroup>(
-  _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
-) -> Dataset<Zip2TensorGroup<T, U>> {
-  let handle = Raw.zipDataset(
-    inputDatasets: [dataset1._handle, dataset2._handle],
-    outputTypes: Zip2TensorGroup<T, U>._typeList,
-    outputShapes: Zip2TensorGroup<T, U>._unknownShapeList)
-  return Dataset(_handle: handle)
-}

From b14a3d5465ed56d28835057ba0014344cdb14804 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Tue, 28 May 2019 02:38:24 -0400
Subject: [PATCH 46/55] Minor bug fixes.

---
 Sources/TensorFlow/Core/DataTypes.swift    | 4 ++--
 Sources/TensorFlow/Core/Runtime.swift      | 8 --------
 Sources/TensorFlow/Core/TensorHandle.swift | 2 +-
 3 files changed, 3 insertions(+), 11 deletions(-)

diff --git a/Sources/TensorFlow/Core/DataTypes.swift b/Sources/TensorFlow/Core/DataTypes.swift
index 2d239e3f8..73ec15191 100644
--- a/Sources/TensorFlow/Core/DataTypes.swift
+++ b/Sources/TensorFlow/Core/DataTypes.swift
@@ -15,11 +15,11 @@
 import CTensorFlow
 
 public extension TensorDataType {
-    public var _cDataType: TF_DataType {
+    var _cDataType: TF_DataType {
         return TF_DataType(rawValue: _internalStorageType)
     }
 
-    public init(_ cDataType: TF_DataType) {
+    init(_ cDataType: TF_DataType) {
 	    self.init(rawValue: cDataType.rawValue)
 	}
 }
diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index 3a53d3b73..3e293b648 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -647,14 +647,6 @@ public final class _ExecutionContext {
       deviceNames.append(deviceName)
     }
 
-    if tpuCount > 0 {
-      // According to server def generated when you set
-      // SWIFT_TENSORFLOW_SERVER_ADDRESS, the TPUs will all be on task 1.
-      self.tpuDeviceNamePrefix = "/job:localhost/replica:0/task:1/device:TPU:"
-    } else {
-      self.tpuDeviceNamePrefix = nil
-    }
-
     pthread_mutex_init(&mutex, nil)
   }
 
diff --git a/Sources/TensorFlow/Core/TensorHandle.swift b/Sources/TensorFlow/Core/TensorHandle.swift
index c98acc294..9a7dfbb57 100644
--- a/Sources/TensorFlow/Core/TensorHandle.swift
+++ b/Sources/TensorFlow/Core/TensorHandle.swift
@@ -26,7 +26,7 @@ public protocol _AnyTensorHandle: class {
 
 extension _AnyTensorHandle {
     /// The underlying `TFE_TensorHandle *`.
-    public let _cTensorHandle: CTensorHandle {
+    public var _cTensorHandle: CTensorHandle {
         return _tfeTensorHandle._cTensorHandle
     }
 }

From f9c3d8d68ac5e5fbfcdc0b1f1bfc811a363290c8 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Tue, 28 May 2019 02:39:47 -0400
Subject: [PATCH 47/55] Fixed a typo.

---
 Tests/TensorFlowTests/OperatorTests/DatasetTests.swift | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Tests/TensorFlowTests/OperatorTests/DatasetTests.swift b/Tests/TensorFlowTests/OperatorTests/DatasetTests.swift
index 1c58fb5c6..722761243 100644
--- a/Tests/TensorFlowTests/OperatorTests/DatasetTests.swift
+++ b/Tests/TensorFlowTests/OperatorTests/DatasetTests.swift
@@ -13,9 +13,9 @@
 // limitations under the License.
 
 import XCTest
-import DeepLearning
+import TensorFlow
 
-struct SimpleOutput : TensorGroup {
+struct SimpleOutput: TensorGroup {
     let a: TensorHandle<Int32>
     let b: TensorHandle<Int32>
 }

From 852e5c062a7756ceb72423b6af29705ff52b7346 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Tue, 28 May 2019 02:42:42 -0400
Subject: [PATCH 48/55] Updated some of the tests.

---
 Tests/TensorFlowTests/LayerTests.swift        |  2 +-
 .../OperatorTests/MathTests.swift             | 32 +++++++++----------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/Tests/TensorFlowTests/LayerTests.swift b/Tests/TensorFlowTests/LayerTests.swift
index f904d6772..47e157d16 100644
--- a/Tests/TensorFlowTests/LayerTests.swift
+++ b/Tests/TensorFlowTests/LayerTests.swift
@@ -199,7 +199,7 @@ final class LayerTests: XCTestCase {
                         [[ 0.066890605,   0.049586136, 0.024610005,  0.09341654]],
                         [[ 0.065792546,   0.009325638, 0.06439907,  0.114802904]],
                         [[ 0.055909205, 0.00035158166, 0.054020774,  0.09812111]]])
-        let (𝛁rnn, 𝛁inputs) = pullback(.init(inputs.map { SimpleRNNCell<Float>.State($0) }))
+        let (𝛁rnn, _) = pullback(.init(inputs.map { SimpleRNNCell<Float>.State($0) }))
         XCTAssertEqual(𝛁rnn.cell.weight,
                        [[          0.0,           0.0,           0.0,           0.0],
                         [-0.0051169936,  0.0014167001,  0.0074189613,   0.017496519],
diff --git a/Tests/TensorFlowTests/OperatorTests/MathTests.swift b/Tests/TensorFlowTests/OperatorTests/MathTests.swift
index 9f9a19976..327c7de08 100644
--- a/Tests/TensorFlowTests/OperatorTests/MathTests.swift
+++ b/Tests/TensorFlowTests/OperatorTests/MathTests.swift
@@ -19,49 +19,49 @@ final class MathOperatorTests: XCTestCase {
     func testReduction() {
         // 2 x 5
         let x = Tensor<Float>([[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]])
-        XCTAssertEqual(Tensor(30), x.sum().toHost(shape: []))
+        XCTAssertEqual(Tensor(30), x.sum())
         XCTAssertEqual(
             Tensor(shape: [5], scalars: [2, 4, 6, 8, 10]),
-            x.sum(squeezingAxes: 0).toHost(shape: []))
+            x.sum(squeezingAxes: 0))
         XCTAssertEqual(
             Tensor(shape: [1, 5], scalars: [2, 4, 6, 8, 10]),
-            x.sum(alongAxes: 0).toHost(shape: []))
+            x.sum(alongAxes: 0))
 
-        XCTAssertEqual(Tensor(14400), x.product().toHost(shape: []))
+        XCTAssertEqual(Tensor(14400), x.product())
         XCTAssertEqual(
             Tensor(shape: [5], scalars: [1, 4, 9, 16, 25]),
-            x.product(squeezingAxes: 0).toHost(shape: []))
+            x.product(squeezingAxes: 0))
         XCTAssertEqual(
             Tensor(shape: [1, 5], scalars: [1, 4, 9, 16, 25]),
-            x.product(alongAxes: 0).toHost(shape: []))
+            x.product(alongAxes: 0))
 
-        XCTAssertEqual(Tensor(3), x.mean().toHost(shape: []))
+        XCTAssertEqual(Tensor(3), x.mean())
         XCTAssertEqual(
             Tensor(shape: [5], scalars: [1, 2, 3, 4, 5]),
-            x.mean(squeezingAxes: 0).toHost(shape: []))
+            x.mean(squeezingAxes: 0))
         XCTAssertEqual(
             Tensor(shape: [5], scalars: [1, 2, 3, 4, 5]),
-            x.mean(alongAxes: 0).toHost(shape: []))
+            x.mean(alongAxes: 0))
         XCTAssertEqual(
             Tensor(shape: [2], scalars: [3, 3]),
-            x.mean(squeezingAxes: 1).toHost(shape: []))
+            x.mean(squeezingAxes: 1))
         XCTAssertEqual(
             Tensor(shape: [1, 2], scalars: [3, 3]),
-            x.mean(alongAxes: 1).toHost(shape: []))
+            x.mean(alongAxes: 1))
 
-        XCTAssertEqual(Tensor(2), x.variance().toHost(shape: []))
+        XCTAssertEqual(Tensor(2), x.variance())
         XCTAssertEqual(
             Tensor(shape: [5], scalars: [0, 0, 0, 0, 0]),
-            x.variance(squeezingAxes: 0).toHost(shape: []))
+            x.variance(squeezingAxes: 0))
         XCTAssertEqual(
             Tensor(shape: [5], scalars: [0, 0, 0, 0, 0]),
-            x.variance(alongAxes: 0).toHost(shape: []))
+            x.variance(alongAxes: 0))
         XCTAssertEqual(
             Tensor(shape: [2], scalars: [2, 2]),
-            x.variance(squeezingAxes: 1).toHost(shape: []))
+            x.variance(squeezingAxes: 1))
         XCTAssertEqual(
             Tensor(shape: [1, 2], scalars: [2, 2]),
-            x.variance(alongAxes: 1).toHost(shape: []))
+            x.variance(alongAxes: 1))
     }
 
     func testArgmax() {

From 1a8347a5521c0f49f070511c76d36193bd1cf4bd Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Tue, 28 May 2019 11:11:21 -0400
Subject: [PATCH 49/55] Removed 'InitTensorFlowRuntime'.

---
 Sources/TensorFlow/Core/Runtime.swift | 40 +++++++++++++++++++++++++--
 1 file changed, 38 insertions(+), 2 deletions(-)

diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index 3e293b648..f8fcfa962 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -590,8 +590,44 @@ public final class _ExecutionContext {
     // Initialize the TF runtime exactly once. Only affects local execution
     // (when _RuntimeConfig.tensorFlowServer is set to "").
     if !_RuntimeConfig.tensorFlowRuntimeInitialized {
-      InitTensorFlowRuntime(_RuntimeConfig.printsDebugLog ? 1 : 0,
-                            _RuntimeConfig.tensorflowVerboseLogLevel)
+      var args = ["dummyProgramName"]
+      if _RuntimeConfig.printsDebugLog {
+        args.append("--alsologtostderr")
+      }
+      if _RuntimeConfig.tensorflowVerboseLogLevel > 0 {
+        args.append("--v=\(_RuntimeConfig.tensorflowVerboseLogLevel)")
+      }
+      // Collect all the strings' utf8 bytes into a single array so that we can
+      // address all the strings with a single `flattenedStringBytes.withUnsafeBufferPointer`.
+      var flattenedStringBytes: [Int8] = []
+      var lengths: [Int] = []
+      for arg in args {
+        let bytes = arg.utf8CString
+        flattenedStringBytes.append(contentsOf: bytes)
+        lengths.append(bytes.count)
+      }
+
+      // Calculate the addresses of all the strings within our single buffer, and then call
+      // TF_InitMain.
+      flattenedStringBytes.withUnsafeMutableBufferPointer { flattenedStringBytesBuffer in
+        var stringAddrs: [UnsafeMutablePointer<Int8>?] = []
+        var currentStringAddr = flattenedStringBytesBuffer.baseAddress.map(UnsafeMutablePointer.init)
+        for length in lengths {
+          stringAddrs.append(currentStringAddr)
+          currentStringAddr = currentStringAddr?.advanced(by: length)
+        }
+
+        stringAddrs.withUnsafeMutableBufferPointer { stringAddrsBuffer in
+          var cArgs = [stringAddrsBuffer.baseAddress.map(UnsafeMutablePointer.init)]
+          var cArgsCount = [Int32(args.count)]
+
+          cArgs.withUnsafeMutableBufferPointer { cArgsBuffer in
+            cArgsCount.withUnsafeMutableBufferPointer { cArgsCountBuffer in
+              TF_InitMain(nil, cArgsCountBuffer.baseAddress, cArgsBuffer.baseAddress)
+            }
+          }
+        }
+      }
       _RuntimeConfig.tensorFlowRuntimeInitialized = true
     }
 

From 76c06ad7d807bef3d23f2e0be9d0641b65efa851 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Tue, 28 May 2019 11:17:50 -0400
Subject: [PATCH 50/55] Minor edits.

---
 Tests/TensorFlowTests/OperatorTests/DatasetTests.swift | 2 +-
 Tests/TensorFlowTests/TensorTests.swift                | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Tests/TensorFlowTests/OperatorTests/DatasetTests.swift b/Tests/TensorFlowTests/OperatorTests/DatasetTests.swift
index 722761243..09aac9dbf 100644
--- a/Tests/TensorFlowTests/OperatorTests/DatasetTests.swift
+++ b/Tests/TensorFlowTests/OperatorTests/DatasetTests.swift
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import XCTest
-import TensorFlow
+@testable import TensorFlow
 
 struct SimpleOutput: TensorGroup {
     let a: TensorHandle<Int32>
diff --git a/Tests/TensorFlowTests/TensorTests.swift b/Tests/TensorFlowTests/TensorTests.swift
index 015254875..30c0e9699 100644
--- a/Tests/TensorFlowTests/TensorTests.swift
+++ b/Tests/TensorFlowTests/TensorTests.swift
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 import XCTest
-import TensorFlow
+@testable import TensorFlow
 
 final class TensorTests: XCTestCase {
     func testSimpleCond() {

From bd1c327d6bb6cb7283726b5ab597f4cf9697e4a3 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Tue, 28 May 2019 12:07:02 -0400
Subject: [PATCH 51/55] Fixed indentation in the 'Runtime.swift' file.

---
 Sources/TensorFlow/Core/Runtime.swift | 2142 ++++++++++++-------------
 1 file changed, 1052 insertions(+), 1090 deletions(-)

diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index f8fcfa962..b80ae90e8 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -36,1127 +36,1090 @@ import Glibc
 #endif
 import CTensorFlow
 
-/// TraceContext contains the state needed to build a trace graph function
-/// (TF_Function). As eager ops are executed in tracing mode, their
-/// corresponding nodes are added to the trace graph (via
-/// `addEagerOpToGraph()`). When the trace is finalized (via `finalize()`), the
-/// trace graph function can then be executed (via `execute()`) by the eager
-/// runtime.
+/// TraceContext contains the state needed to build a trace graph function (TF_Function). As eager 
+/// ops are executed in tracing mode, their corresponding nodes are added to the trace graph (via
+/// `addEagerOpToGraph()`). When the trace is finalized (via `finalize()`), the trace graph function 
+/// can then be executed (via `execute()`) by the eager runtime.
 @usableFromInline
 internal class TraceContext {
-  let status: CTFStatus = TF_NewStatus()
-
-  /// The trace graph, which will be converted to a trace graph function
-  /// (TF_Function) upon finalizing.
-  let graph = TF_NewGraph()
-
-  /// The list of inputs to the trace graph function. It starts with the inputs
-  /// to the function that we trace (referred to as the "tracee function" or
-  /// "tracee"), followed by possible additional inputs that correspond to
-  /// concrete tensors produced within the trace function.
-  ///
-  /// For example, if the tracee is:
-  ///
-  /// struct TensorPair<T : TensorGroup, U : TensorGroup> : TensorGroup {
-  ///   public var first: T
-  ///   public var second: U
-  /// }
-  ///
-  /// func foo(x: TensorPair) -> Tensor {
-  ///   let y = Tensor<Float>(1.0)
-  ///   return x.first + x.second + y
-  /// }
-  ///
-  /// Then the generated trace graph function has 3 input tensors: x.first,
-  /// x.second, and y.
-  ///
-  /// These symbolic tensors corresond to PlaceHolder nodes in the trace graph,
-  /// and will be filled in when we execute the trace graph function.
-  //
-  // TODO: If some tensors in `x` are not used within `foo()`, they can be
-  // pruned away in the inputs to the trace graph function.
-  var symbolicInputs: [TF_Output] = []
-
-  /// The outputs obtained by executing the `tracee` for computing the trace.
-  var tracedOutputs: [CTensorHandle] = []
-
-  /// The trace context object used in TF C API calls that convert eager ops to
-  /// (trace) graph nodes.
-  let cTraceContext: CTFETraceContext
-
-  /// The trace graph function created by `finalize()`.
-  var traceGraphFn: CTFFunction?
-
-  /// The number of additional input tensors to the trace graph function,
-  /// created from concrete intermediate tensors in the tracee, such as `y` in
-  /// the code snippet above.
-  var additionalInputTensorCount: Int32 = -1
-
-  /// `dtypes` is the (flattened) list of TF_DataType of input tensors
-  /// to the trace function.
-  init(dtypes: [TF_DataType]) {
-    debugLog("Instiantiating TraceContext with \(dtypes.count) input tensors.")
-    for (i, dtype) in dtypes.enumerated() {
-      let desc = TF_NewOperation(graph, "Placeholder", "input_\(i)")
-      TF_SetAttrType(desc, "dtype", dtype)
-      let result = TF_FinishOperation(desc, status)
-      checkOk(status)
-      symbolicInputs.append(TF_Output(oper: result, index: 0))
-    }
-    cTraceContext = TFE_NewTraceContext(graph)
-  }
-
-  deinit {
-    TFE_DeleteTraceContext(cTraceContext)
-    TF_DeleteGraph(graph)
-    TF_DeleteStatus(status)
-  }
-
-  @usableFromInline
-  func addEagerOpToGraph(_ op: CTFEOp,
-                      _ retvals: UnsafeMutablePointer<OpaquePointer?>,
-                      _ retvalCount: UnsafeMutablePointer<Int32>,
-                      _ status: CTFStatus) {
-    TFE_AddEagerOpToGraph(op, cTraceContext, retvals, retvalCount, status)
-    checkOk(status)
-  }
-
-  /// Finalize the trace graph function.
-  func finalize(traceeBasicName: String) {
-    internalConsistencyCheck(traceGraphFn == nil)
-    var symbolicOutputs: [TF_Output] = []
-    // Only add symbolic output tensors as the outputs of the trace graph function.
-    // For example, let the tracee be:
-    //   func foo(x: Tensor) -> (Tensor, Tensor) {
-    //     let y = Tensor<Float>(1.0)
-    //     return (x + x, y)
-    //   }
+    let status: CTFStatus = TF_NewStatus()
+
+    /// The trace graph, which will be converted to a trace graph function upon finalizing.
+    let graph = TF_NewGraph()
+
+    /// The list of inputs to the trace graph function. It starts with the inputs to the function 
+    /// that we trace (referred to as the "tracee function" or "tracee"), followed by possible 
+    /// additional inputs that correspond to concrete tensors produced within the trace function.
+    ///
+    /// For example, if the tracee is:
+    ///
+    /// struct TensorPair<T: TensorGroup, U: TensorGroup>: TensorGroup {
+    ///   public var first: T
+    ///   public var second: U
+    /// }
+    ///
+    /// func foo(x: TensorPair) -> Tensor {
+    ///   let y = Tensor<Float>(1.0)
+    ///   return x.first + x.second + y
+    /// }
+    ///
+    /// Then the generated trace graph function has 3 input tensors: x.first, x.second, and y.
+    ///
+    /// These symbolic tensors corresond to PlaceHolder nodes in the trace graph, and will be filled 
+    /// in when we execute the trace graph function.
     //
-    // Here foo() returns 2 tensors, but only the first one (as computed by x +
-    // x) is symbolic. The second one for y is concrete, and is computed at
-    // trace creation time, not trace execution time.
-    // Also see the comment block above finalizeAndExecuteTraceFn().
-    for (i, tracedOutput) in tracedOutputs.enumerated()
-        where TFE_TensorHandleIsConcrete(tracedOutput) == 0 {
-      debugLog("Adding symbolic tracedOutput \(i) as a trace graph func output.")
-      symbolicOutputs.append(TFE_GetTFOutputFromTensorHandle(tracedOutput ,status))
-      checkOk(status)
+    // TODO: If some tensors in `x` are not used within `foo()`, they can be pruned away in the 
+    // inputs to the trace graph function.
+    var symbolicInputs: [TF_Output] = []
+
+    /// The outputs obtained by executing the `tracee` for computing the trace.
+    var tracedOutputs: [CTensorHandle] = []
+
+    /// The trace context object used in TF C API calls that convert eager ops to (trace) graph
+    /// nodes.
+    let cTraceContext: CTFETraceContext
+
+    /// The trace graph function created by `finalize()`.
+    var traceGraphFn: CTFFunction?
+
+    /// The number of additional input tensors to the trace graph function, created from concrete 
+    /// intermediate tensors in the tracee, such as `y` in the code snippet above.
+    var additionalInputTensorCount: Int32 = -1
+
+    /// `dtypes` is the (flattened) list of TF_DataType of input tensors to the trace function.
+    init(dtypes: [TF_DataType]) {
+        debugLog("Instiantiating TraceContext with \(dtypes.count) input tensors.")
+        for (i, dtype) in dtypes.enumerated() {
+            let desc = TF_NewOperation(graph, "Placeholder", "input_\(i)")
+            TF_SetAttrType(desc, "dtype", dtype)
+            let result = TF_FinishOperation(desc, status)
+            checkOk(status)
+            symbolicInputs.append(TF_Output(oper: result, index: 0))
+        }
+        cTraceContext = TFE_NewTraceContext(graph)
     }
 
-    let traceeInputCount = symbolicInputs.count
-    // Append concrete tensors created within the tracee as symbolic inputs to
-    // the generated trace graph function.
-    additionalInputTensorCount = TFE_FinalizeInputTensorsFromTraceContext(
-      cTraceContext)
-    for i in 0..<additionalInputTensorCount {
-      symbolicInputs.append(TFE_GetInputGraphNodeFromTraceContext(
-                              cTraceContext, UInt32(i)))
+    deinit {
+        TFE_DeleteTraceContext(cTraceContext)
+        TF_DeleteGraph(graph)
+        TF_DeleteStatus(status)
     }
 
-    let tracedFunctionName =
-      "\(traceeBasicName)_\(_RuntimeConfig.traceGraphFunctionCounter)"
-    _RuntimeConfig.traceGraphFunctionCounter += 1
-    debugLog("""
-               Finalizing trace graph func \(tracedFunctionName), with \
-               \(traceeInputCount) tracee inputs and \
-               \(additionalInputTensorCount) additional inputs, and up to \
-               \(tracedOutputs.count) return values.
-               """)
-    traceGraphFn =
-      TF_GraphToFunction(graph, tracedFunctionName,
-                         /*append_hash_to_fn_name*/ 0,
-                         /*num_opers*/ -1,
-                         /*opers*/ nil,
-                         /*numinputs*/ Int32(symbolicInputs.count),
-                         /*inputs*/ symbolicInputs,
-                         /*noutputs*/ Int32(symbolicOutputs.count),
-                         /*outputs*/ symbolicOutputs,
-                         /*outputnames*/ nil,
-                         /*functionoptions*/ nil, "", status)
-    checkOk(status)
-
-    if _RuntimeConfig.printsDebugLog {
-      var len: Int = 0
-      let funcDebugStr = TF_FunctionDebugString(traceGraphFn, &len)!
-      debugLog("The traced function is:\n\(String(cString: funcDebugStr))")
-      free(funcDebugStr)
-    }
-
-    // TODO: Consider garbage-collecting these trace graph functions if we end
-    // up with many of them.
-    let eagerContext = _TFCGetGlobalEagerContext()
-    TFE_ContextAddFunction(eagerContext, traceGraphFn, status)
-    checkOk(status)
-  }
-
-  /// Execute the trace graph function, and return the list of output tensors
-  /// from the trace execution. These output tensors are owned by the caller.
-  func execute(
-    traceeInputs: [_AnyTensorHandle], useXLA: Bool = false) -> [CTensorHandle] {
-    // We must be in the `notTracing` enum mode.
-    internalConsistencyCheck(_RuntimeConfig.traceState.context == nil)
-    internalConsistencyCheck(traceGraphFn != nil)
-
-    let tracedFunctionName = TF_FunctionName(traceGraphFn)
-    internalConsistencyCheck(tracedFunctionName != nil)
-    let eagerContext = _TFCGetGlobalEagerContext()
-    let op: CTFEOp! = TFE_NewOp(eagerContext, tracedFunctionName, status)
-    defer { TFE_DeleteOp(op) }
-    checkOk(status)
-
-    let deviceName = _ExecutionContext.global.currentDeviceName
-    if let deviceName = deviceName {
-      debugLog("Placing the trace func on device \(deviceName).")
-      TFE_OpSetDevice(op, deviceName, status)
-      checkOk(status)
+    @usableFromInline
+    func addEagerOpToGraph(
+        _ op: CTFEOp,
+        _ retvals: UnsafeMutablePointer<OpaquePointer?>,
+        _ retvalCount: UnsafeMutablePointer<Int32>,
+        _ status: CTFStatus
+    ) {
+        TFE_AddEagerOpToGraph(op, cTraceContext, retvals, retvalCount, status)
+        checkOk(status)
     }
 
-    if useXLA {
-      debugLog("Enabling XLA compilation")
-      TFE_OpSetAttrBool(op, "_XlaCompile", 1)
-    }
+    /// Finalize the trace graph function.
+    func finalize(traceeBasicName: String) {
+        internalConsistencyCheck(traceGraphFn == nil)
+        var symbolicOutputs: [TF_Output] = []
+        // Only add symbolic output tensors as the outputs of the trace graph function.
+        // For example, let the tracee be:
+        //   func foo(x: Tensor) -> (Tensor, Tensor) {
+        //     let y = Tensor<Float>(1.0)
+        //     return (x + x, y)
+        //   }
+        //
+        // Here foo() returns 2 tensors, but only the first one (as computed by x + x) is symbolic.
+        // The second one for y is concrete, and is computed at trace creation time, not trace 
+        // execution time. Also see the comment block above finalizeAndExecuteTraceFn().
+        for (i, tracedOutput) in tracedOutputs.enumerated()
+        where TFE_TensorHandleIsConcrete(tracedOutput) == 0 {
+            debugLog("Adding symbolic tracedOutput \(i) as a trace graph func output.")
+            symbolicOutputs.append(TFE_GetTFOutputFromTensorHandle(tracedOutput ,status))
+            checkOk(status)
+        }
 
-    debugLog("Adding \(traceeInputs.count) tracee input tensors.")
-    internalConsistencyCheck(symbolicInputs.count == traceeInputs.count
-                               + Int(additionalInputTensorCount))
-    for input in traceeInputs {
-      _TFCOpAddInputFromTensorHandle(op, input, status)
-      checkOk(status)
-    }
+        let traceeInputCount = symbolicInputs.count
+        // Append concrete tensors created within the tracee as symbolic inputs to the generated 
+        // trace graph function.
+        additionalInputTensorCount = TFE_FinalizeInputTensorsFromTraceContext(cTraceContext)
+        for i in 0..<additionalInputTensorCount {
+            symbolicInputs.append(TFE_GetInputGraphNodeFromTraceContext(cTraceContext, UInt32(i)))
+        }
 
-    debugLog("Adding \(additionalInputTensorCount) additional input tensors.")
-    for i in 0..<additionalInputTensorCount {
-      let input = TFE_ConsumeInputConcreteTensorFromTraceContext(cTraceContext,
-                                                                 UInt32(i))
-      internalConsistencyCheck(input != nil)
-      debugLog("""
-                 Adding additional input tensor of idx \
-                 \(traceeInputs.count+Int(additionalInputTensorCount)):\
-                 \(input!).
+        let tracedFunctionName = "\(traceeBasicName)_\(_RuntimeConfig.traceGraphFunctionCounter)"
+        _RuntimeConfig.traceGraphFunctionCounter += 1
+        debugLog("""
+                 Finalizing trace graph func \(tracedFunctionName), with \
+                 \(traceeInputCount) tracee inputs and \
+                 \(additionalInputTensorCount) additional inputs, and up to \
+                 \(tracedOutputs.count) return values.
                  """)
-      TFE_OpAddInput(op, input, status)
-      checkOk(status)
-    }
+        traceGraphFn = TF_GraphToFunction(
+            graph,
+            tracedFunctionName,
+            /*append_hash_to_fn_name*/ 0,
+            /*num_opers*/ -1,
+            /*opers*/ nil,
+            /*numinputs*/ Int32(symbolicInputs.count),
+            /*inputs*/ symbolicInputs,
+            /*noutputs*/ Int32(symbolicOutputs.count),
+            /*outputs*/ symbolicOutputs,
+            /*outputnames*/ nil,
+            /*functionoptions*/ nil, "", status)
+        checkOk(status)
 
-    // Tell TensorFlow to execute the graph function we built, containing
-    // the trace.
-    let maxReturnValueCount = tracedOutputs.count
-    debugLog("""
-               Executing trace func \(tracedFunctionName!) with up to \
-               \(maxReturnValueCount) return values.
-               """)
-    var returnValues = [CTensorHandle?](repeating: nil,
-                                        count: maxReturnValueCount)
-    var outputReturnValueCount = Int32(maxReturnValueCount)
-    TFE_Execute(op, &returnValues, &outputReturnValueCount, status)
-    checkOk(status)
-    debugLog("""
-               returnValues.count=\(returnValues.count), \
-               outputReturnValueCount=\(outputReturnValueCount).
-               """)
-    internalConsistencyCheck(outputReturnValueCount <= returnValues.count)
-
-    // Now that all the output elements have been filled in, remove a level of
-    // optional, and also add concrete outputs.
-    var traceGraphOutputs: [CTensorHandle] = []
-    // Points to an element in `returnValues`.
-    var returnValueIdx = 0
-    // See the comment block within finalize() below on why we handle concrete
-    // and symbolic output tensors differently.
-    for tracedOutput in tracedOutputs {
-      if TFE_TensorHandleIsConcrete(tracedOutput) != 0 {
-        // These concrete tensors are owned by some other objects, so we make a
-        // copy here.
-        let newOutput = TFE_TensorHandleCopySharingTensor(tracedOutput, status)
+        if _RuntimeConfig.printsDebugLog {
+            var len: Int = 0
+            let funcDebugStr = TF_FunctionDebugString(traceGraphFn, &len)!
+            debugLog("The traced function is:\n\(String(cString: funcDebugStr))")
+            free(funcDebugStr)
+        }
+
+        // TODO: Consider garbage-collecting these trace graph functions if we end up with too many.
+        let eagerContext = _TFCGetGlobalEagerContext()
+        TFE_ContextAddFunction(eagerContext, traceGraphFn, status)
         checkOk(status)
-        internalConsistencyCheck(newOutput != nil)
-        traceGraphOutputs.append(newOutput!)
-      } else {
-        // These symbolic tensors are produced by TFE_Execute() above, and we
-        // need not make an extra copy.
-        internalConsistencyCheck(returnValues[returnValueIdx] != nil)
-        traceGraphOutputs.append(returnValues[returnValueIdx]!)
-        returnValueIdx += 1
-      }
-    }
-    internalConsistencyCheck(returnValueIdx == outputReturnValueCount)
-    return traceGraphOutputs
-  }
-
-  /// Bind data to the inputs of the graph and return the specialized graph.
-  func specializeTFFunction(with dataTensors: [CTensorHandle]) -> String {
-    let specializedGraph = TF_NewGraph()!
-
-    TF_GraphCopyFunction(
-      specializedGraph, traceGraphFn, /*gradient*/ nil, status)
-    checkOk(status)
-
-    let tracedFunctionName = TF_FunctionName(traceGraphFn)
-    internalConsistencyCheck(tracedFunctionName != nil)
-    let tracedOpDesc = TF_NewOperation(
-      specializedGraph, tracedFunctionName, "tracedFn")
-
-    // Create and append the inputs to the graph function.
-    let traceeInputs = symbolicInputs.dropLast(
-      dataTensors.count + Int(additionalInputTensorCount))
-    var inputs: [TF_Output] = []
-    for (i, traceeInput) in traceeInputs.enumerated() {
-      let desc = TF_NewOperation(specializedGraph, "Placeholder", "input_\(i)")
-      TF_SetAttrType(desc, "dtype", TF_OperationOutputType(traceeInput))
-      let result = TF_FinishOperation(desc, status)
-      checkOk(status)
-      let input = TF_Output(oper: result, index: 0)
-      TF_AddInput(tracedOpDesc, input)
-      inputs.append(input)
     }
 
-    // Wire the data to the corresponding inputs of the tracedOp.
-    for (i, cTensorHandle) in dataTensors.enumerated() {
-      let cTensor = TFE_TensorHandleResolve(cTensorHandle, status)
-      checkOk(status)
-      let desc = TF_NewOperation(specializedGraph, "Const", "input_const_\(i)")
-      TF_SetAttrType(desc, "dtype", TFE_TensorHandleDataType(cTensorHandle))
-      TF_SetAttrTensor(desc, "value", cTensor, status)
-      checkOk(status)
-      let result = TF_FinishOperation(desc, status)
-      checkOk(status)
-      TF_AddInput(tracedOpDesc, TF_Output(oper: result, index: 0))
-    }
+    /// Execute the trace graph function, and return the list of output tensors from the trace
+    /// execution. These output tensors are owned by the caller.
+    func execute(
+        traceeInputs: [_AnyTensorHandle],
+        useXLA: Bool = false
+    ) -> [CTensorHandle] {
+        // We must be in the `notTracing` enum mode.
+        internalConsistencyCheck(_RuntimeConfig.traceState.context == nil)
+        internalConsistencyCheck(traceGraphFn != nil)
+
+        let tracedFunctionName = TF_FunctionName(traceGraphFn)
+        internalConsistencyCheck(tracedFunctionName != nil)
+        let eagerContext = _TFCGetGlobalEagerContext()
+        let op: CTFEOp! = TFE_NewOp(eagerContext, tracedFunctionName, status)
+        defer { TFE_DeleteOp(op) }
+        checkOk(status)
+
+        let deviceName = _ExecutionContext.global.currentDeviceName
+        if let deviceName = deviceName {
+            debugLog("Placing the trace func on device \(deviceName).")
+            TFE_OpSetDevice(op, deviceName, status)
+            checkOk(status)
+        }
+
+        if useXLA {
+            debugLog("Enabling XLA compilation")
+            TFE_OpSetAttrBool(op, "_XlaCompile", 1)
+        }
 
-    var nextConst = dataTensors.count
-    debugLog("Adding \(additionalInputTensorCount) additional input tensors.")
-    for i in 0..<additionalInputTensorCount {
-      let cTensorHandle =
-        TFE_ConsumeInputConcreteTensorFromTraceContext(cTraceContext, UInt32(i))
-      internalConsistencyCheck(cTensorHandle != nil)
-      let cTensor = TFE_TensorHandleResolve(cTensorHandle, status)
-      checkOk(status)
-      let desc = TF_NewOperation(
-        specializedGraph, "Const", "input_const_\(nextConst)")
-      nextConst += 1
-      TF_SetAttrType(desc, "dtype", TFE_TensorHandleDataType(cTensorHandle))
-      TF_SetAttrTensor(desc, "value", cTensor, status)
-      checkOk(status)
-      debugLog("""
-                 Adding additional input tensor of idx \
-                 \(traceeInputs.count+Int(additionalInputTensorCount)):\
-                 \(cTensorHandle!).
+        debugLog("Adding \(traceeInputs.count) tracee input tensors.")
+        internalConsistencyCheck(
+            symbolicInputs.count == traceeInputs.count + Int(additionalInputTensorCount))
+        for input in traceeInputs {
+            _TFCOpAddInputFromTensorHandle(op, input, status)
+            checkOk(status)
+        }
+
+        debugLog("Adding \(additionalInputTensorCount) additional input tensors.")
+        for i in 0..<additionalInputTensorCount {
+            let input = TFE_ConsumeInputConcreteTensorFromTraceContext(cTraceContext, UInt32(i))
+            internalConsistencyCheck(input != nil)
+            debugLog("""
+                     Adding additional input tensor of idx \
+                     \(traceeInputs.count+Int(additionalInputTensorCount)):\
+                     \(input!).
+                     """)
+            TFE_OpAddInput(op, input, status)
+            checkOk(status)
+        }
+
+        // Tell TensorFlow to execute the graph function we built, containing the trace.
+        let maxReturnValueCount = tracedOutputs.count
+        debugLog("""
+                 Executing trace func \(tracedFunctionName!) with up to \
+                 \(maxReturnValueCount) return values.
                  """)
-      let result = TF_FinishOperation(desc, status)
-      checkOk(status)
-      TF_AddInput(tracedOpDesc, TF_Output(oper: result, index: 0))
+        var returnValues = [CTensorHandle?](repeating: nil, count: maxReturnValueCount)
+        var outputReturnValueCount = Int32(maxReturnValueCount)
+        TFE_Execute(op, &returnValues, &outputReturnValueCount, status)
+        checkOk(status)
+        debugLog("""
+                 returnValues.count=\(returnValues.count), \
+                 outputReturnValueCount=\(outputReturnValueCount).
+                 """)
+        internalConsistencyCheck(outputReturnValueCount <= returnValues.count)
+
+        // Now that all the output elements have been filled in, remove a level of optional, and 
+        // also add concrete outputs.
+        var traceGraphOutputs: [CTensorHandle] = []
+        // Points to an element in `returnValues`.
+        var returnValueIdx = 0
+        // See the comment block within finalize() below on why we handle concrete and symbolic 
+        // output tensors differently.
+        for tracedOutput in tracedOutputs {
+            if TFE_TensorHandleIsConcrete(tracedOutput) != 0 {
+                // These concrete tensors are owned by some other objects, so we make a copy here.
+                let newOutput = TFE_TensorHandleCopySharingTensor(tracedOutput, status)
+                checkOk(status)
+                internalConsistencyCheck(newOutput != nil)
+                traceGraphOutputs.append(newOutput!)
+            } else {
+                // These symbolic tensors are produced by TFE_Execute() above, and we need not make 
+                // an extra copy.
+                internalConsistencyCheck(returnValues[returnValueIdx] != nil)
+                traceGraphOutputs.append(returnValues[returnValueIdx]!)
+                returnValueIdx += 1
+            }
+        }
+        internalConsistencyCheck(returnValueIdx == outputReturnValueCount)
+        return traceGraphOutputs
     }
 
-    let tracedOp = TF_FinishOperation(tracedOpDesc, status)
-    checkOk(status)
-
-    // Set up outputs.
-    var outputIndex: Int32 = 0
-    var outputs: [TF_Output] = []
-    // Get the symbolic outputs from the output.
-    for output in tracedOutputs
-      where TFE_TensorHandleIsConcrete(output) == 0 {
-      outputs.append(TF_Output(oper: tracedOp, index: outputIndex))
-      outputIndex += 1
-    }
-    // Create constants for the concrete outputs.
-    for output in tracedOutputs
-      where TFE_TensorHandleIsConcrete(output) != 0 {
-      let cTensor = TFE_TensorHandleResolve(output, status)
-      checkOk(status)
-      let desc = TF_NewOperation(
-        specializedGraph, "Const", "output_const_\(outputIndex)")
-      TF_SetAttrType(desc, "dtype", TFE_TensorHandleDataType(output))
-      TF_SetAttrTensor(desc, "value", cTensor, status);
-      checkOk(status)
-      let result = TF_FinishOperation(desc, status)
-      checkOk(status)
-      outputs.append(TF_Output(oper: result, index: outputIndex))
-      outputIndex += 1
-    }
-    let specializedTFFuncName =
-      "specialized_tffunc_\(_RuntimeConfig.traceGraphFunctionCounter)"
-    _RuntimeConfig.traceGraphFunctionCounter += 1
-
-    let tffunc =
-      TF_GraphToFunction(specializedGraph, specializedTFFuncName,
-                         /*append_hash_to_fn_name*/ 0,
-                         /*num_opers*/ -1,
-                         /*opers*/ nil,
-                         /*numinputs*/ Int32(inputs.count),
-                         /*inputs*/ inputs,
-                         /*noutputs*/ Int32(outputs.count),
-                         /*outputs*/ outputs,
-                         /*outputnames*/ nil,
-                         /*functionoptions*/ nil, "", status)
-    checkOk(status)
+    /// Bind data to the inputs of the graph and return the specialized graph.
+    func specializeTFFunction(with dataTensors: [CTensorHandle]) -> String {
+        let specializedGraph = TF_NewGraph()!
 
-    if _RuntimeConfig.printsDebugLog {
-      var len: Int = 0
-      let funcDebugStr = TF_FunctionDebugString(tffunc, &len)!
-      debugLog("Specialized TF_Function is:\n\(String(cString: funcDebugStr))")
-      free(funcDebugStr)
+        TF_GraphCopyFunction(specializedGraph, traceGraphFn, /*gradient*/ nil, status)
+        checkOk(status)
+
+        let tracedFunctionName = TF_FunctionName(traceGraphFn)
+        internalConsistencyCheck(tracedFunctionName != nil)
+        let tracedOpDesc = TF_NewOperation(specializedGraph, tracedFunctionName, "tracedFn")
+
+        // Create and append the inputs to the graph function.
+        let traceeInputs = symbolicInputs.dropLast(
+            dataTensors.count + Int(additionalInputTensorCount))
+        var inputs: [TF_Output] = []
+        for (i, traceeInput) in traceeInputs.enumerated() {
+            let desc = TF_NewOperation(specializedGraph, "Placeholder", "input_\(i)")
+            TF_SetAttrType(desc, "dtype", TF_OperationOutputType(traceeInput))
+            let result = TF_FinishOperation(desc, status)
+            checkOk(status)
+            let input = TF_Output(oper: result, index: 0)
+            TF_AddInput(tracedOpDesc, input)
+            inputs.append(input)
+        }
+
+        // Wire the data to the corresponding inputs of the tracedOp.
+        for (i, cTensorHandle) in dataTensors.enumerated() {
+            let cTensor = TFE_TensorHandleResolve(cTensorHandle, status)
+            checkOk(status)
+            let desc = TF_NewOperation(specializedGraph, "Const", "input_const_\(i)")
+            TF_SetAttrType(desc, "dtype", TFE_TensorHandleDataType(cTensorHandle))
+            TF_SetAttrTensor(desc, "value", cTensor, status)
+            checkOk(status)
+            let result = TF_FinishOperation(desc, status)
+            checkOk(status)
+            TF_AddInput(tracedOpDesc, TF_Output(oper: result, index: 0))
+        }
+
+        var nextConst = dataTensors.count
+        debugLog("Adding \(additionalInputTensorCount) additional input tensors.")
+        for i in 0..<additionalInputTensorCount {
+            let cTensorHandle = TFE_ConsumeInputConcreteTensorFromTraceContext(
+                cTraceContext, UInt32(i))
+            internalConsistencyCheck(cTensorHandle != nil)
+            let cTensor = TFE_TensorHandleResolve(cTensorHandle, status)
+            checkOk(status)
+            let desc = TF_NewOperation(specializedGraph, "Const", "input_const_\(nextConst)")
+            nextConst += 1
+            TF_SetAttrType(desc, "dtype", TFE_TensorHandleDataType(cTensorHandle))
+            TF_SetAttrTensor(desc, "value", cTensor, status)
+            checkOk(status)
+            debugLog("""
+                     Adding additional input tensor of idx \
+                     \(traceeInputs.count+Int(additionalInputTensorCount)):\
+                     \(cTensorHandle!).
+                     """)
+            let result = TF_FinishOperation(desc, status)
+            checkOk(status)
+            TF_AddInput(tracedOpDesc, TF_Output(oper: result, index: 0))
+        }
+
+        let tracedOp = TF_FinishOperation(tracedOpDesc, status)
+        checkOk(status)
+
+        // Set up outputs.
+        var outputIndex: Int32 = 0
+        var outputs: [TF_Output] = []
+        // Get the symbolic outputs from the output.
+        for output in tracedOutputs
+        where TFE_TensorHandleIsConcrete(output) == 0 {
+            outputs.append(TF_Output(oper: tracedOp, index: outputIndex))
+            outputIndex += 1
+        }
+        // Create constants for the concrete outputs.
+        for output in tracedOutputs
+        where TFE_TensorHandleIsConcrete(output) != 0 {
+            let cTensor = TFE_TensorHandleResolve(output, status)
+            checkOk(status)
+            let desc = TF_NewOperation(specializedGraph, "Const", "output_const_\(outputIndex)")
+            TF_SetAttrType(desc, "dtype", TFE_TensorHandleDataType(output))
+            TF_SetAttrTensor(desc, "value", cTensor, status);
+            checkOk(status)
+            let result = TF_FinishOperation(desc, status)
+            checkOk(status)
+            outputs.append(TF_Output(oper: result, index: outputIndex))
+            outputIndex += 1
+        }
+        let specializedTFFuncName = "specialized_tffunc_\(_RuntimeConfig.traceGraphFunctionCounter)"
+        _RuntimeConfig.traceGraphFunctionCounter += 1
+
+        let tffunc = TF_GraphToFunction(
+            specializedGraph,
+            specializedTFFuncName,
+            /*append_hash_to_fn_name*/ 0,
+            /*num_opers*/ -1,
+            /*opers*/ nil,
+            /*numinputs*/ Int32(inputs.count),
+            /*inputs*/ inputs,
+            /*noutputs*/ Int32(outputs.count),
+            /*outputs*/ outputs,
+            /*outputnames*/ nil,
+            /*functionoptions*/ nil, "", status)
+        checkOk(status)
+
+        if _RuntimeConfig.printsDebugLog {
+            var len: Int = 0
+            let funcDebugStr = TF_FunctionDebugString(tffunc, &len)!
+            debugLog("Specialized TF_Function is:\n\(String(cString: funcDebugStr))")
+            free(funcDebugStr)
+        }
+        let eagerContext = _TFCGetGlobalEagerContext()
+        TFE_ContextAddFunction(eagerContext, tffunc, status)
+        checkOk(status)
+        return specializedTFFuncName
     }
-    let eagerContext = _TFCGetGlobalEagerContext()
-    TFE_ContextAddFunction(eagerContext, tffunc, status)
-    checkOk(status)
-    return specializedTFFuncName
-  }
 }
 
 // This enum keeps track of whether we are building or executing a trace.
 @usableFromInline
 internal enum TracingState {
-  case notTracing
-  case tracing(TraceContext)
-
-  // Return nil if we are not in tracing mode.
-  @usableFromInline
-  var context: TraceContext? {
-    guard case let .tracing(context) = self else { return nil }
-    return context
-  }
+    case notTracing
+    case tracing(TraceContext)
+
+    // Return nil if we are not in tracing mode.
+    @usableFromInline
+    var context: TraceContext? {
+        guard case let .tracing(context) = self else { return nil }
+        return context
+    }
 }
 
 /// The configuration for the compiler runtime.
 // TODO(hongm): Revisit the longer-term design.
 // @_frozen // SR-9739
 public enum _RuntimeConfig {
-  // TODO: change this and subsequent properties from static to thread local.
-  @usableFromInline
-  internal static var traceState: TracingState = .notTracing
-
-  /// Used to create unique trace graph function names.
-  fileprivate static var traceGraphFunctionCounter = 0
-
-  /// When false, tensorflow runtime will be initialized before running any
-  /// tensor program in this process.
-  static public var tensorFlowRuntimeInitialized = false
-
-  /// When true, let TensorFlow GPU memory allocation start small and grow as
-  /// needed. Otherwise, The entire GPU memory region is pre-allocated.
-  static public var gpuMemoryAllowGrowth = true
-
-  /// The number of CPU devices.
-  static public var cpuDeviceCount: UInt32 = 1
-
-  /// When non-nil, run metadata (with full trace) of each session execution
-  /// will be dumped to the give path.
-  static public var runMetadataOutputPath: String? = nil
-
-  /// Specifies whether the TensorFlow computation runs in a local (in-process)
-  /// session, or a remote session with the specified server definition.
-  // @_frozen // SR-9739
-  public enum RuntimeSession {
-    case local
-    case remote(serverDef: String)
-  }
-  static public var session: RuntimeSession = .local
-
-  /// When true, prints various debug messages on the runtime state.
-  ///
-  /// If the value is true when running tensor computation for the first time in
-  /// the process, INFO log from TensorFlow will also get printed.
-  static public var printsDebugLog = false
-
-  /// Specifies the verbose log level in TensorFlow; a higher level prints out
-  /// more log. Only meaningful when `printsDebugLog` is true, and must be
-  /// within [0, 4] in that case.
-  static public var tensorflowVerboseLogLevel: Int32 = 0 {
-    willSet {
-      debugLog("About to set tensorflowVerboseLogLevel to \(newValue)")
-      guard newValue >= 0 && newValue <= 4 else {
-        fatalError("Invalid tensorflowVerboseLogLevel value \(newValue)")
-      }
+    // TODO: change this and subsequent properties from static to thread local.
+    @usableFromInline
+    internal static var traceState: TracingState = .notTracing
+
+    /// Used to create unique trace graph function names.
+    fileprivate static var traceGraphFunctionCounter = 0
+
+    /// When false, tensorflow runtime will be initialized before running any tensor program in this 
+    /// process.
+    static public var tensorFlowRuntimeInitialized = false
+
+    /// When true, let TensorFlow GPU memory allocation start small and grow as needed. Otherwise, 
+    /// The entire GPU memory region is pre-allocated.
+    static public var gpuMemoryAllowGrowth = true
+
+    /// The number of CPU devices.
+    static public var cpuDeviceCount: UInt32 = 1
+
+    /// When non-nil, run metadata (with full trace) of each session execution will be dumped to the 
+    /// give path.
+    static public var runMetadataOutputPath: String? = nil
+
+    /// Specifies whether the TensorFlow computation runs in a local (in-process) session, or a 
+    /// remote session with the specified server definition.
+    // @_frozen // SR-9739
+    public enum RuntimeSession {
+        case local
+        case remote(serverDef: String)
+    }
+    static public var session: RuntimeSession = .local
+
+    /// When true, prints various debug messages on the runtime state.
+    ///
+    /// If the value is true when running tensor computation for the first time in the process, INFO 
+    /// log from TensorFlow will also get printed.
+    static public var printsDebugLog = false
+
+    /// Specifies the verbose log level in TensorFlow; a higher level prints out more log. Only 
+    /// meaningful when `printsDebugLog` is true, and must be within [0, 4] in that case.
+    static public var tensorflowVerboseLogLevel: Int32 = 0 {
+        willSet {
+            debugLog("About to set tensorflowVerboseLogLevel to \(newValue)")
+            guard newValue >= 0 && newValue <= 4 else {
+                fatalError("Invalid tensorflowVerboseLogLevel value \(newValue)")
+            }
+        }
     }
-  }
 }
 
 private func configureRuntimeFromEnvironment() {
-  if let value = getenv("SWIFT_TENSORFLOW_ENABLE_DEBUG_LOGGING"),
-    String(cString: value).lowercased() == "true" {
-      _RuntimeConfig.printsDebugLog = true
-      debugLog("Turning on debug logging from env.")
-  }
-
-  if let value = getenv("SWIFT_TENSORFLOW_VERBOSE_LOG_LEVEL") {
-    guard var verboseLevel = Int32(String(cString: value)) else {
-      fatalError("SWIFT_TENSORFLOW_VERBOSE_LOG_LEVEL must take an int value.")
+    if let value = getenv("SWIFT_TENSORFLOW_ENABLE_DEBUG_LOGGING"),
+       String(cString: value).lowercased() == "true" {
+            _RuntimeConfig.printsDebugLog = true
+            debugLog("Turning on debug logging from env.")
     }
-    if verboseLevel > 4 {
-      verboseLevel = 4
+
+    if let value = getenv("SWIFT_TENSORFLOW_VERBOSE_LOG_LEVEL") {
+        guard var verboseLevel = Int32(String(cString: value)) else {
+            fatalError("SWIFT_TENSORFLOW_VERBOSE_LOG_LEVEL must take an int value.")
+        }
+        if verboseLevel > 4 {
+            verboseLevel = 4
+        }
+        _RuntimeConfig.tensorflowVerboseLogLevel = verboseLevel
+        debugLog("Setting TF logging verbose level to \(verboseLevel) from env.")
     }
-    _RuntimeConfig.tensorflowVerboseLogLevel = verboseLevel
-    debugLog("Setting TF logging verbose level to \(verboseLevel) from env.")
-  }
-
-  if let value = getenv("SWIFT_TENSORFLOW_SERVER_ADDRESS") {
-    let address = String(cString: value)
-    debugLog("Env var SWIFT_TENSORFLOW_SERVER_ADDRESS has value \(address).")
-    if address == "local" {
-      _RuntimeConfig.session = .local
-      debugLog("Using local TF session.")
-    } else {
-      guard let idx = address.firstIndex(of: ":"),
-         let endIdx = address.index(idx, offsetBy: 3, limitedBy: address.endIndex),
-         address[idx..<endIdx] == "://" else {
-        fatalError("SWIFT_TENSORFLOW_SERVER_ADDRESS must start with 'grpc://'.")
-      }
-
-      let `protocol` = address[address.startIndex..<idx]
-      let target = address[endIdx..<address.endIndex]
-      _RuntimeConfig.session = .remote(serverDef: """
-        cluster {
-          job {
-            name: "localhost"
-            tasks {
-              key: 0
-              value: "127.0.0.1:0"
+
+    if let value = getenv("SWIFT_TENSORFLOW_SERVER_ADDRESS") {
+        let address = String(cString: value)
+        debugLog("Env var SWIFT_TENSORFLOW_SERVER_ADDRESS has value \(address).")
+        if address == "local" {
+            _RuntimeConfig.session = .local
+            debugLog("Using local TF session.")
+        } else {
+            guard let idx = address.firstIndex(of: ":"),
+                let endIdx = address.index(idx, offsetBy: 3, limitedBy: address.endIndex),
+                address[idx..<endIdx] == "://" else {
+                fatalError("SWIFT_TENSORFLOW_SERVER_ADDRESS must start with 'grpc://'.")
             }
-            tasks {
-              key: 1
-              value: "\(target)"
+
+            let `protocol` = address[address.startIndex..<idx]
+            let target = address[endIdx..<address.endIndex]
+            _RuntimeConfig.session = .remote(serverDef: """
+                cluster {
+                job {
+                    name: "localhost"
+                    tasks {
+                    key: 0
+                    value: "127.0.0.1:0"
+                    }
+                    tasks {
+                    key: 1
+                    value: "\(target)"
+                    }
+                }
+                }
+                job_name: "localhost"
+                task_index: 0
+                protocol: "\(`protocol`)"
+                """)
+            debugLog("Setting TF server address to \(address) from env.")
+
+            // At the moment, without TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC=1, running on TPUs freezes.
+            // Therefore, we set this environment variable to 1 unless it's set explicitly.
+            if let value = getenv("TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC") {
+                debugLog("TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC already set:")
+                debugLog(String(cString: value))
+            } else {
+                setenv("TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC", "1", /*override*/ 0)
+                debugLog("Setting TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC to 1")
             }
-          }
         }
-        job_name: "localhost"
-        task_index: 0
-        protocol: "\(`protocol`)"
-        """)
-      debugLog("Setting TF server address to \(address) from env.")
-
-      // At the moment, without TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC=1,
-      // running on TPUs freezes. Therefore, we set this environment variable
-      // to 1 unless it's set explicitly.
-      if let value = getenv("TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC") {
-        debugLog("TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC already set:")
-        debugLog(String(cString: value))
-      } else {
-        setenv("TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC", "1", /*override*/ 0)
-        debugLog("Setting TF_EAGER_REMOTE_USE_SEND_TENSOR_RPC to 1")
-      }
     }
-  }
 
-  if let value = getenv("SWIFT_TENSORFLOW_RUN_METADATA_OUTPUT") {
-    let path = String(cString: value)
-    _RuntimeConfig.runMetadataOutputPath = path
-    debugLog("Setting run metadata output path to \(path) from env.")
-  }
+    if let value = getenv("SWIFT_TENSORFLOW_RUN_METADATA_OUTPUT") {
+        let path = String(cString: value)
+        _RuntimeConfig.runMetadataOutputPath = path
+        debugLog("Setting run metadata output path to \(path) from env.")
+    }
 
-  if let value = getenv("SWIFT_TENSORFLOW_CPU_DEVICE_COUNT") {
-    guard let cpuDeviceCount = UInt32(String(cString: value)) else {
-      fatalError("SWIFT_TENSORFLOW_CPU_DEVICE_COUNT must take an int value.")
+    if let value = getenv("SWIFT_TENSORFLOW_CPU_DEVICE_COUNT") {
+        guard let cpuDeviceCount = UInt32(String(cString: value)) else {
+            fatalError("SWIFT_TENSORFLOW_CPU_DEVICE_COUNT must take an int value.")
+        }
+        _RuntimeConfig.cpuDeviceCount = cpuDeviceCount
+        debugLog("Setting number of CPU devices to \(cpuDeviceCount) from env.")
     }
-    _RuntimeConfig.cpuDeviceCount = cpuDeviceCount
-    debugLog("Setting number of CPU devices to \(cpuDeviceCount) from env.")
-  }
 }
 
 /// The host of any tensor computation.
 @_fixed_layout
 public final class _ExecutionContext {
-  /// Global context storing all available devices, loaded functions, etc.
-  public static let global: _ExecutionContext = _ExecutionContext()
-
-  /// List of devices available to this execution context.
-  /// Devices are represented by their names in TensorFlow notation.
-  /// See documentation for `withDevice(named:perform:)` to learn about device names.
-  private var deviceNames: [String] = []
-
-  /// The buffer storing a serialized TensorFlow config proto.
-  public let tensorFlowConfig: UnsafeMutablePointer<TF_Buffer>
-
-  /// The TFE_Context object.
-  @usableFromInline
-  internal let eagerContext: CTFEContext
-
-  /// The status for checking TensorFlow errors.
-  private let status: CTFStatus = TF_NewStatus()
-
-  /// The mutex for preventing potential concurrent access.
-  private var mutex: pthread_mutex_t = pthread_mutex_t()
-
-  /// Initializes a new execution context by initializing available devices.
-  @usableFromInline
-  init() {
-    configureRuntimeFromEnvironment()
-
-    // Suppress TensorFlow logging, unless the user specified a log level.
-    setenv("TF_CPP_MIN_LOG_LEVEL", "3", /*override*/ 0)
-
-    debugLog("Initializing global context.")
-
-    // Initialize the TF runtime exactly once. Only affects local execution
-    // (when _RuntimeConfig.tensorFlowServer is set to "").
-    if !_RuntimeConfig.tensorFlowRuntimeInitialized {
-      var args = ["dummyProgramName"]
-      if _RuntimeConfig.printsDebugLog {
-        args.append("--alsologtostderr")
-      }
-      if _RuntimeConfig.tensorflowVerboseLogLevel > 0 {
-        args.append("--v=\(_RuntimeConfig.tensorflowVerboseLogLevel)")
-      }
-      // Collect all the strings' utf8 bytes into a single array so that we can
-      // address all the strings with a single `flattenedStringBytes.withUnsafeBufferPointer`.
-      var flattenedStringBytes: [Int8] = []
-      var lengths: [Int] = []
-      for arg in args {
-        let bytes = arg.utf8CString
-        flattenedStringBytes.append(contentsOf: bytes)
-        lengths.append(bytes.count)
-      }
-
-      // Calculate the addresses of all the strings within our single buffer, and then call
-      // TF_InitMain.
-      flattenedStringBytes.withUnsafeMutableBufferPointer { flattenedStringBytesBuffer in
-        var stringAddrs: [UnsafeMutablePointer<Int8>?] = []
-        var currentStringAddr = flattenedStringBytesBuffer.baseAddress.map(UnsafeMutablePointer.init)
-        for length in lengths {
-          stringAddrs.append(currentStringAddr)
-          currentStringAddr = currentStringAddr?.advanced(by: length)
-        }
+    /// Global context storing all available devices, loaded functions, etc.
+    public static let global: _ExecutionContext = _ExecutionContext()
+
+    /// List of devices available to this execution context.
+    /// Devices are represented by their names in TensorFlow notation.
+    /// See documentation for `withDevice(named:perform:)` to learn about device names.
+    private var deviceNames: [String] = []
+
+    /// The buffer storing a serialized TensorFlow config proto.
+    public let tensorFlowConfig: UnsafeMutablePointer<TF_Buffer>
+
+    /// The TFE_Context object.
+    @usableFromInline
+    internal let eagerContext: CTFEContext
+
+    /// The status for checking TensorFlow errors.
+    private let status: CTFStatus = TF_NewStatus()
+
+    /// The mutex for preventing potential concurrent access.
+    private var mutex: pthread_mutex_t = pthread_mutex_t()
+
+    /// Initializes a new execution context by initializing available devices.
+    @usableFromInline
+    init() {
+        configureRuntimeFromEnvironment()
 
-        stringAddrs.withUnsafeMutableBufferPointer { stringAddrsBuffer in
-          var cArgs = [stringAddrsBuffer.baseAddress.map(UnsafeMutablePointer.init)]
-          var cArgsCount = [Int32(args.count)]
+        // Suppress TensorFlow logging, unless the user specified a log level.
+        setenv("TF_CPP_MIN_LOG_LEVEL", "3", /*override*/ 0)
 
-          cArgs.withUnsafeMutableBufferPointer { cArgsBuffer in
-            cArgsCount.withUnsafeMutableBufferPointer { cArgsCountBuffer in
-              TF_InitMain(nil, cArgsCountBuffer.baseAddress, cArgsBuffer.baseAddress)
+        debugLog("Initializing global context.")
+
+        // Initialize the TF runtime exactly once. Only affects local execution
+        // (when _RuntimeConfig.tensorFlowServer is set to "").
+        if !_RuntimeConfig.tensorFlowRuntimeInitialized {
+            var args = ["dummyProgramName"]
+            if _RuntimeConfig.printsDebugLog {
+                args.append("--alsologtostderr")
+            }
+            if _RuntimeConfig.tensorflowVerboseLogLevel > 0 {
+                args.append("--v=\(_RuntimeConfig.tensorflowVerboseLogLevel)")
+            }
+            // Collect all the strings' utf8 bytes into a single array so that we can
+            // address all the strings with a single `flattenedStringBytes.withUnsafeBufferPointer`.
+            var flattenedStringBytes: [Int8] = []
+            var lengths: [Int] = []
+            for arg in args {
+                let bytes = arg.utf8CString
+                flattenedStringBytes.append(contentsOf: bytes)
+                lengths.append(bytes.count)
+            }
+
+            // Calculate the addresses of all the strings within our single buffer, and then call
+            // TF_InitMain.
+            flattenedStringBytes.withUnsafeMutableBufferPointer { flattenedStringBytesBuffer in
+                var stringAddrs: [UnsafeMutablePointer<Int8>?] = []
+                var currentStringAddr = flattenedStringBytesBuffer.baseAddress
+                    .map(UnsafeMutablePointer.init)
+                for length in lengths {
+                    stringAddrs.append(currentStringAddr)
+                    currentStringAddr = currentStringAddr?.advanced(by: length)
+                }
+
+                stringAddrs.withUnsafeMutableBufferPointer { stringAddrsBuffer in
+                    var cArgs = [stringAddrsBuffer.baseAddress.map(UnsafeMutablePointer.init)]
+                    var cArgsCount = [Int32(args.count)]
+
+                    cArgs.withUnsafeMutableBufferPointer { cArgsBuffer in
+                        cArgsCount.withUnsafeMutableBufferPointer { cArgsCountBuffer in
+                            TF_InitMain(nil, cArgsCountBuffer.baseAddress, cArgsBuffer.baseAddress)
+                        }
+                    }
+                }
             }
-          }
+            _RuntimeConfig.tensorFlowRuntimeInitialized = true
         }
-      }
-      _RuntimeConfig.tensorFlowRuntimeInitialized = true
-    }
 
-    guard let opts = TFE_NewContextOptions() else {
-      fatalError("ContextOptions object can never be nil.")
-    }
+        guard let opts = TFE_NewContextOptions() else {
+            fatalError("ContextOptions object can never be nil.")
+        }
 
-    // Create TF config object.
-    if _RuntimeConfig.gpuMemoryAllowGrowth {
-      debugLog("Allowing growth for GPU memory allocator.")
-    }
-    self.tensorFlowConfig = TF_CreateConfig(
-      /* enable_xla_compilation */ 0,
-      _RuntimeConfig.gpuMemoryAllowGrowth ? 1 : 0,
-      _RuntimeConfig.cpuDeviceCount)
-    TFE_ContextOptionsSetConfig(opts,
-                                tensorFlowConfig.pointee.data,
-                                tensorFlowConfig.pointee.length,
-                                status)
-    checkOk(status)
-
-    let ctx = TFE_NewContext(opts, status)
-    checkOk(status)
-    self.eagerContext = ctx!
-    TFE_DeleteContextOptions(opts)
-    checkOk(status)
-
-    if case .remote(let serverDef) = _RuntimeConfig.session {
-      debugLog("Setting up the server def to \(serverDef)...")
-      let serverDef: UnsafeMutablePointer! =
-        TFE_GetServerDef(serverDef, status)
-      checkOk(status)
-      TFE_ContextSetServerDef(eagerContext, /*keep_alive_secs*/0,
-        serverDef.pointee.data, serverDef.pointee.length, status)
-      checkOk(status)
-      TF_DeleteBuffer(serverDef)
-    }
+        // Create TF config object.
+        if _RuntimeConfig.gpuMemoryAllowGrowth {
+            debugLog("Allowing growth for GPU memory allocator.")
+        }
+        self.tensorFlowConfig = TF_CreateConfig(
+            /* enable_xla_compilation */ 0,
+            _RuntimeConfig.gpuMemoryAllowGrowth ? 1 : 0,
+            _RuntimeConfig.cpuDeviceCount)
+        TFE_ContextOptionsSetConfig(opts,
+                                    tensorFlowConfig.pointee.data,
+                                    tensorFlowConfig.pointee.length,
+                                    status)
+        checkOk(status)
+
+        let ctx = TFE_NewContext(opts, status)
+        checkOk(status)
+        self.eagerContext = ctx!
+        TFE_DeleteContextOptions(opts)
+        checkOk(status)
 
-    let devices = TFE_ContextListDevices(eagerContext, status)
-    checkOk(status)
-    defer { TF_DeleteDeviceList(devices!) }
-
-    let deviceCount = TF_DeviceListCount(devices!)
-    debugLog("There are \(deviceCount) devices.")
-    for deviceId in 0..<deviceCount {
-      let cDeviceName = TF_DeviceListName(devices, deviceId, status)
-      checkOk(status)
-      let deviceName = String(cString: cDeviceName!)
-      let cDeviceType = TF_DeviceListType(devices, deviceId, status)
-      checkOk(status)
-      let deviceType = String(cString: cDeviceType!)
-      debugLog("Device \(deviceId) has type \(deviceType) and name \(deviceName).")
-      deviceNames.append(deviceName)
+        if case .remote(let serverDef) = _RuntimeConfig.session {
+            debugLog("Setting up the server def to \(serverDef)...")
+            let serverDef: UnsafeMutablePointer! = TFE_GetServerDef(serverDef, status)
+            checkOk(status)
+            TFE_ContextSetServerDef(
+                eagerContext, /*keep_alive_secs*/0, serverDef.pointee.data, 
+                serverDef.pointee.length, status)
+            checkOk(status)
+            TF_DeleteBuffer(serverDef)
+        }
+
+        let devices = TFE_ContextListDevices(eagerContext, status)
+        checkOk(status)
+        defer { TF_DeleteDeviceList(devices!) }
+
+        let deviceCount = TF_DeviceListCount(devices!)
+        debugLog("There are \(deviceCount) devices.")
+        for deviceId in 0..<deviceCount {
+            let cDeviceName = TF_DeviceListName(devices, deviceId, status)
+            checkOk(status)
+            let deviceName = String(cString: cDeviceName!)
+            let cDeviceType = TF_DeviceListType(devices, deviceId, status)
+            checkOk(status)
+            let deviceType = String(cString: cDeviceType!)
+            debugLog("Device \(deviceId) has type \(deviceType) and name \(deviceName).")
+            deviceNames.append(deviceName)
+        }
+
+        pthread_mutex_init(&mutex, nil)
     }
 
-    pthread_mutex_init(&mutex, nil)
-  }
-
-  deinit {
-    debugLog("De-initializing global context.")
-    // Delete all loaded programs.
-    TFE_DeleteContext(eagerContext)
-    TF_DeleteBuffer(tensorFlowConfig)
-    TF_DeleteStatus(status)
-    pthread_mutex_destroy(&mutex)
-  }
+    deinit {
+        debugLog("De-initializing global context.")
+        // Delete all loaded programs.
+        TFE_DeleteContext(eagerContext)
+        TF_DeleteBuffer(tensorFlowConfig)
+        TF_DeleteStatus(status)
+        pthread_mutex_destroy(&mutex)
+    }
 }
 
 extension _ExecutionContext {
-  // The execution mode is effectively encoded in the TensorOperation.
-  // We can use this to switch between different execution modes.
-  // TODO: Can we interop between modes?
-  public static func makeOp(_ name: String, _ nOutputs: Int) -> TFTensorOperation {
-    return TFE_Op(name, nOutputs)
-  }
+    // The execution mode is effectively encoded in the TensorOperation.
+    // We can use this to switch between different execution modes.
+    // TODO: Can we interop between modes?
+    public static func makeOp(_ name: String, _ nOutputs: Int) -> TFTensorOperation {
+        return TFE_Op(name, nOutputs)
+    }
 }
 
 // Elements in `outputs` can come from two sources:
 // a) Symbolic tensors produced by tensor ops, and added as trace graph nodes.
 // b) Concrete tensors produced by host code (e.g. Tensor(1.0)).
 fileprivate func finalizeTraceFunction(_ name: String) -> TraceContext {
-  guard let traceContext = _RuntimeConfig.traceState.context else {
-    fatalError("Not in tracing mode!.")
-  }
-  _RuntimeConfig.traceState = .notTracing
-  traceContext.finalize(traceeBasicName: name)
-  return traceContext
+    guard let traceContext = _RuntimeConfig.traceState.context else {
+        fatalError("Not in tracing mode!.")
+    }
+    _RuntimeConfig.traceState = .notTracing
+    traceContext.finalize(traceeBasicName: name)
+    return traceContext
 }
 
 private extension TensorArrayProtocol {
-  // The returned handles are owned by the caller.
-  var cTensorHandles: [CTensorHandle] {
-    debugLog("Getting \(self._tensorHandleCount) C handles.")
-    let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(
-      capacity: Int(self._tensorHandleCount))
-    debugLog("Unpacking handles into buffer.")
-    _unpackTensorHandles(into: buffer)
-    let status = TF_NewStatus()
-    debugLog("Copying buffer content to output handles.")
-    var output: [CTensorHandle] = []
-    for i in 0..<Int(_tensorHandleCount) {
-      let address = buffer.advanced(by: i)
-      let isConcrete = TFE_TensorHandleIsConcrete(address.pointee) != 0
-      debugLog("""
-                 Copying the \(i)-th C handle \(address.pointee) with \
-                 concrete=\(isConcrete).
-                 """)
-      let newHandle = TFE_TensorHandleCopySharingTensor(address.pointee,
-                                                        status)
-      checkOk(status)
-      internalConsistencyCheck(newHandle != nil)
-      debugLog("""
-                 Copying the \(i)-th C handle \(address.pointee) with \
-                 concrete=\(isConcrete) to C handle create \(newHandle!).
-                 """)
-      output.append(newHandle!)
+    // The returned handles are owned by the caller.
+    var cTensorHandles: [CTensorHandle] {
+        debugLog("Getting \(self._tensorHandleCount) C handles.")
+        let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(
+            capacity: Int(self._tensorHandleCount))
+        debugLog("Unpacking handles into buffer.")
+        _unpackTensorHandles(into: buffer)
+        let status = TF_NewStatus()
+        debugLog("Copying buffer content to output handles.")
+        var output: [CTensorHandle] = []
+        for i in 0..<Int(_tensorHandleCount) {
+            let address = buffer.advanced(by: i)
+            let isConcrete = TFE_TensorHandleIsConcrete(address.pointee) != 0
+            debugLog("""
+                     Copying the \(i)-th C handle \(address.pointee) with \
+                     concrete=\(isConcrete).
+                     """)
+            let newHandle = TFE_TensorHandleCopySharingTensor(address.pointee, status)
+            checkOk(status)
+            internalConsistencyCheck(newHandle != nil)
+            debugLog("""
+                     Copying the \(i)-th C handle \(address.pointee) with \
+                     concrete=\(isConcrete) to C handle create \(newHandle!).
+                     """)
+            output.append(newHandle!)
+        }
+        TF_DeleteStatus(status)
+        return output
     }
-    TF_DeleteStatus(status)
-    return output
-  }
 }
 
 private extension TensorGroup {
-  // The tensors in `input` are NOT owned by this instance.
-  init<C: Collection>(_copying input: C) where C.Element == CTensorHandle {
-    assert(Self._tensorHandleCount == input.count)
-    let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(
-      capacity: input.count)
-    let status = TF_NewStatus()
-    // copy input to buffer
-    for (i, inputTensorHandle) in input.enumerated() {
-      let address = buffer.advanced(by: i)
-      // Each tensor can be symbolic (e.g. when using this API to create a
-      // symbolic input instance to tracee) or concrete (e.g. when creating the
-      // final output of the tracee).
-      let newHandle = TFE_TensorHandleCopySharingTensor(inputTensorHandle,
-                                                        status)
-      checkOk(status)
-      address.initialize(to: newHandle!)
+    // The tensors in `input` are NOT owned by this instance.
+    init<C: Collection>(_copying input: C) where C.Element == CTensorHandle {
+        assert(Self._tensorHandleCount == input.count)
+        let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(capacity: input.count)
+        let status = TF_NewStatus()
+        // copy input to buffer
+        for (i, inputTensorHandle) in input.enumerated() {
+            let address = buffer.advanced(by: i)
+            // Each tensor can be symbolic (e.g. when using this API to create a symbolic input 
+            // instance to tracee) or concrete (e.g. when creating the final output of the tracee).
+            let newHandle = TFE_TensorHandleCopySharingTensor(inputTensorHandle, status)
+            checkOk(status)
+            address.initialize(to: newHandle!)
+        }
+        TF_DeleteStatus(status)
+        self.init(_owning: buffer)
     }
-    TF_DeleteStatus(status)
-    self.init(_owning: buffer)
-  }
-
-  init<C: Collection>(_owning input: C) where C.Element == CTensorHandle {
-    assert(Self._tensorHandleCount == input.count)
-    let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(
-      capacity: input.count)
-    let status = TF_NewStatus()
-    // copy input to buffer
-    for (i, inputTensorHandle) in input.enumerated() {
-      let address = buffer.advanced(by: i)
-      address.initialize(to: inputTensorHandle)
+
+    init<C: Collection>(_owning input: C) where C.Element == CTensorHandle {
+        assert(Self._tensorHandleCount == input.count)
+        let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(capacity: input.count)
+        let status = TF_NewStatus()
+        // copy input to buffer
+        for (i, inputTensorHandle) in input.enumerated() {
+            let address = buffer.advanced(by: i)
+            address.initialize(to: inputTensorHandle)
+        }
+        TF_DeleteStatus(status)
+        self.init(_owning: buffer)
     }
-    TF_DeleteStatus(status)
-    self.init(_owning: buffer)
-  }
 }
 
 // TODO: Fold this protocol into TensorArrayProtocol.
-// This requires that we move concrete implementation such as
-// Tensor._makeInstance() to TensorGroup.swift.
-public protocol _TensorArrayProtocolEnhanced : TensorArrayProtocol {
-  // Create an instance based on `inputs`, which can be symbolic (e.g. when
-  // creating a symbolic input to tracee) or concrete (e.g. when creating a
-  // final output of executing the tracee).
-  func _makeInstance<C: Collection>(owning inputs: C) -> Self
-    where C.Element == CTensorHandle
+// This requires that we move concrete implementation such as Tensor._makeInstance() to 
+// TensorGroup.swift.
+public protocol _TensorArrayProtocolEnhanced: TensorArrayProtocol {
+    // Create an instance based on `inputs`, which can be symbolic (e.g., when creating a symbolic
+    // input to tracee) or concrete (e.., when creating a final output of executing the tracee).
+    func _makeInstance<C: Collection>(owning inputs: C) -> Self where C.Element == CTensorHandle
 }
 
-
 extension _TensorArrayProtocolEnhanced {
-  var _dtypes: [TF_DataType] {
-    let count = Int(_tensorHandleCount)
-    let buffer =
-        UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: count)
-    defer { buffer.deallocate() }
-    _unpackTensorHandles(into: buffer.baseAddress)
-    return buffer.map { TFE_TensorHandleDataType($0) }
-  }
+    var _dtypes: [TF_DataType] {
+        let count = Int(_tensorHandleCount)
+        let buffer = UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: count)
+        defer { buffer.deallocate() }
+        _unpackTensorHandles(into: buffer.baseAddress)
+        return buffer.map { TFE_TensorHandleDataType($0) }
+    }
 }
 
 /// Trace `fn` with newly created tensor handles and return a trace context.
 private func _trace(
-  with dtypes: [TF_DataType],
-  in fn: ([CTensorHandle]) -> [CTensorHandle]
+    with dtypes: [TF_DataType],
+    in fn: ([CTensorHandle]) -> [CTensorHandle]
 ) -> TraceContext {
-  debugLog("""
-             Tracing over a function with \(dtypes.count) inputs.
-             """)
+    debugLog("""
+            Tracing over a function with \(dtypes.count) inputs.
+            """)
+
+    // Verify that we are not already tracing.
+    internalConsistencyCheck(_RuntimeConfig.traceState.context == nil,
+                             "Should not be in tracing mode already!")
+
+    // Switch to tracing mode.
+    let traceCtx = TraceContext(dtypes: dtypes)
+    _RuntimeConfig.traceState = .tracing(traceCtx)
 
-  // Verify that we are not already tracing.
-  internalConsistencyCheck(_RuntimeConfig.traceState.context == nil,
-                           "Should not be in tracing mode already!")
-
-  // Switch to tracing mode.
-  let traceCtx = TraceContext(dtypes: dtypes)
-  _RuntimeConfig.traceState = .tracing(traceCtx)
-
-  // Handle inputs.
-  let inputSymbolicTensors = traceCtx.symbolicInputs.map {
-    TFE_NewTensorHandleFromTFOutput($0, TF_OperationOutputType($0))!
-  }
-  internalConsistencyCheck(inputSymbolicTensors.count == dtypes.count)
-
-  // Run tracee to build the trace, adding ops to the trace graph function.
-  // The tracee output can contain a mixture of symbolic and concrete tensors
-  // (see the comment block within TraceContext.finalize()).
-   debugLog("Running tracee in tracing mode.")
-  traceCtx.tracedOutputs = fn(inputSymbolicTensors)
-
-  debugLog("Finalizing trace graph function.")
-  // TAP means tensor array protocol.
-  let opType = "MyTraceFn_TAP"
-  return finalizeTraceFunction(opType)
+    // Handle inputs.
+    let inputSymbolicTensors = traceCtx.symbolicInputs.map {
+        TFE_NewTensorHandleFromTFOutput($0, TF_OperationOutputType($0))!
+    }
+    internalConsistencyCheck(inputSymbolicTensors.count == dtypes.count)
+
+    // Run tracee to build the trace, adding ops to the trace graph function. The tracee output can
+    // contain a mixture of symbolic and concrete tensors (see the comment block within
+    // TraceContext.finalize()).
+    debugLog("Running tracee in tracing mode.")
+    traceCtx.tracedOutputs = fn(inputSymbolicTensors)
+
+    debugLog("Finalizing trace graph function.")
+    // TAP means tensor array protocol.
+    let opType = "MyTraceFn_TAP"
+    return finalizeTraceFunction(opType)
 }
 
-private func _graphInternal<State : _TensorArrayProtocolEnhanced,
-                            Data : TensorGroup,
-                            Result : TensorGroup>(
-  with state: State,
-  in fn: (State, Data) -> (State, Result?)
+private func _graphInternal<State: _TensorArrayProtocolEnhanced,
+                            Data: TensorGroup,
+                            Result: TensorGroup>(
+    with state: State,
+    in fn: (State, Data) -> (State, Result?)
 ) -> (State, Data) -> (State, Result?) {
-  let traceContext: TraceContext = withoutActuallyEscaping(fn) { escapableFn in
-    let wrappedFn = { (inputs: [CTensorHandle]) -> [CTensorHandle] in
-      let symbolicState = state._makeInstance(
-        owning: inputs.dropLast(Data._typeList.count))
-      let symbolicData = Data(
-        _copying: inputs.dropFirst(Int(state._tensorHandleCount)))
-      let (outputState, outputResult) = escapableFn(symbolicState, symbolicData)
-
-      debugLog("Assembling output tensor handles.")
-      let outputs =
-        outputResult != nil
-          ? (outputState.cTensorHandles + outputResult!.cTensorHandles)
-          : outputState.cTensorHandles
-      return outputs
+    let traceContext: TraceContext = withoutActuallyEscaping(fn) { escapableFn in
+        let wrappedFn = { (inputs: [CTensorHandle]) -> [CTensorHandle] in
+            let symbolicState = state._makeInstance(owning: inputs.dropLast(Data._typeList.count))
+            let symbolicData = Data(_copying: inputs.dropFirst(Int(state._tensorHandleCount)))
+            let (outputState, outputResult) = escapableFn(symbolicState, symbolicData)
+
+            debugLog("Assembling output tensor handles.")
+            let outputs =
+                outputResult != nil
+                ? (outputState.cTensorHandles + outputResult!.cTensorHandles)
+                : outputState.cTensorHandles
+            return outputs
+        }
+        let dtypes = state._dtypes + Data._typeList.map { $0._cDataType }
+        return _trace(with: dtypes, in: wrappedFn)
     }
-    let dtypes = state._dtypes + Data._typeList.map { $0._cDataType }
-    return _trace(with: dtypes, in: wrappedFn)
-  }
-  // The result is a closure that captures and executes the trace graph
-  // function in the trace context.
-  return { (oldState: State, data: Data) -> (State, Result?) in
-    debugLog("Running trace function over state \(oldState) and data \(data).")
-
-    debugLog("Getting input state tensor handles.")
-    let inputStateTensorHandles =  oldState.cTensorHandles
-    var inputTensors = inputStateTensorHandles.map {
-      TFETensorHandle(_owning: $0)
+    // The result is a closure that captures and executes the trace graph function in the trace
+    // context.
+    return { (oldState: State, data: Data) -> (State, Result?) in
+        debugLog("Running trace function over state \(oldState) and data \(data).")
+
+        debugLog("Getting input state tensor handles.")
+        let inputStateTensorHandles =  oldState.cTensorHandles
+        var inputTensors = inputStateTensorHandles.map {
+            TFETensorHandle(_owning: $0)
+        }
+        debugLog("Getting input data tensor handles.")
+        let inputDataTensorHandles =  data.cTensorHandles
+        inputTensors.append(contentsOf: inputDataTensorHandles.map {
+            TFETensorHandle(_owning: $0)
+        })
+
+        debugLog("Executing trace graph function.")
+        let returnValues = traceContext.execute(traceeInputs: inputTensors)
+
+        debugLog("Creating output model instance.")
+        let newState = state._makeInstance(
+            owning: returnValues.prefix(Int(state._tensorHandleCount)))
+        let resultValues = returnValues.dropFirst(Int(state._tensorHandleCount))
+        let result: Result? = resultValues.isEmpty ? nil : Result(_owning: resultValues)
+        return (newState, result)
     }
-    debugLog("Getting input data tensor handles.")
-    let inputDataTensorHandles =  data.cTensorHandles
-    inputTensors.append(contentsOf: inputDataTensorHandles.map {
-      TFETensorHandle(_owning: $0)
-    })
-
-    debugLog("Executing trace graph function.")
-    let returnValues = traceContext.execute(traceeInputs: inputTensors)
-
-    debugLog("Creating output model instance.")
-    let newState = state._makeInstance(owning: returnValues.prefix(
-                                         Int(state._tensorHandleCount)))
-    let resultValues = returnValues.dropFirst(Int(state._tensorHandleCount))
-    let result: Result? = resultValues.isEmpty ? nil : Result(_owning: resultValues)
-    return (newState, result)
-  }
 }
 
 // TODO: rename this to `graph` when it's ready for end users.
-public func _graph<State : _TensorArrayProtocolEnhanced,
-                   Data : TensorGroup,
-                   Result : TensorGroup>(
-  with state: State,
-  in fn: (State, Data) -> (State, Result)
+public func _graph<State: _TensorArrayProtocolEnhanced,
+                   Data: TensorGroup,
+                   Result: TensorGroup>(
+    with state: State,
+    in fn: (State, Data) -> (State, Result)
 ) -> (State, Data) -> (State, Result) {
-  let graphFunction = _graphInternal(with: state, in: fn)
-  return { (state: State, data: Data) in
-    let result = graphFunction(state, data)
-    internalConsistencyCheck(result.1 != nil)
-    return (result.0, result.1!)
-  }
+    let graphFunction = _graphInternal(with: state, in: fn)
+    return { (state: State, data: Data) in
+        let result = graphFunction(state, data)
+        internalConsistencyCheck(result.1 != nil)
+        return (result.0, result.1!)
+    }
 }
 
 // TODO: rename this to `graph` when it's ready for end users.
 public func _graph<State : _TensorArrayProtocolEnhanced, Data : TensorGroup>(
-  with state: State,
-  in fn: (State, Data) -> State
+    with state: State,
+    in fn: (State, Data) -> State
 ) -> (State, Data) -> State {
-  let graphFunction: (State, Data) -> (State, TensorHandle<Float>?) =
-    withoutActuallyEscaping(fn) { escapableFn in
-      let wrappedFn = {
-        // The result argument needs to a type that conforms to TensorGroup.
-        // We are arbitrarily picking TensorHandle<Float> here.
-        (s: State, d: Data) -> (State, TensorHandle<Float>?) in
-          (escapableFn(s, d), nil)
-      }
-      return _graphInternal(with: state, in: wrappedFn)
-    }
-  return { (state: State, data: Data) in graphFunction(state, data).0 }
+    let graphFunction: (State, Data) -> (State, TensorHandle<Float>?) =
+        withoutActuallyEscaping(fn) { escapableFn in
+            let wrappedFn = {
+                // The result argument needs to a type that conforms to TensorGroup.
+                // We are arbitrarily picking TensorHandle<Float> here.
+                (s: State, d: Data) -> (State, TensorHandle<Float>?) in
+                (escapableFn(s, d), nil)
+            }
+            return _graphInternal(with: state, in: wrappedFn)
+        }
+    return { (state: State, data: Data) in graphFunction(state, data).0 }
 }
 
-/// Trace the given function `fn` and return a closure that can be used to
-/// create a `TF_Function(State)` specialized for `data`.
-public func _tffunc<State : _TensorArrayProtocolEnhanced,
-                    Data : TensorGroup>(
-  with state: State,
-  in fn: (State, Data) -> State
+/// Trace the given function `fn` and return a closure that can be used to create a 
+/// `TF_Function(State)` specialized for `data`.
+public func _tffunc<State: _TensorArrayProtocolEnhanced, Data: TensorGroup>(
+    with state: State,
+    in fn: (State, Data) -> State
 ) -> (Data) -> (String) {
-  let traceContext: TraceContext = withoutActuallyEscaping(fn) { escapableFn in
-    let wrappedFn = { (inputs: [CTensorHandle]) -> [CTensorHandle] in
-      let symbolicState = state._makeInstance(
-        owning: inputs.dropLast(Data._typeList.count))
-      let symbolicData = Data(
-        _copying: inputs.dropFirst(Int(state._tensorHandleCount)))
-      let outputState = escapableFn(symbolicState, symbolicData)
-      return outputState.cTensorHandles
+    let traceContext: TraceContext = withoutActuallyEscaping(fn) { escapableFn in
+        let wrappedFn = { (inputs: [CTensorHandle]) -> [CTensorHandle] in
+            let symbolicState = state._makeInstance(owning: inputs.dropLast(Data._typeList.count))
+            let symbolicData = Data(_copying: inputs.dropFirst(Int(state._tensorHandleCount)))
+            let outputState = escapableFn(symbolicState, symbolicData)
+            return outputState.cTensorHandles
+        }
+        let dtypes = state._dtypes + Data._typeList.map { $0._cDataType }
+        return _trace(with: dtypes, in: wrappedFn)
+    }
+    return {
+        data in traceContext.specializeTFFunction(with: data.cTensorHandles)
     }
-    let dtypes = state._dtypes + Data._typeList.map { $0._cDataType }
-    return _trace(with: dtypes, in: wrappedFn)
-  }
-  return {
-    data in traceContext.specializeTFFunction(with: data.cTensorHandles)
-  }
 }
 
-// Trace the given function to generate a TF graph and return a closure
-// that can be used to launch the graph.
-public func _graph<In : TensorGroup, Out : TensorGroup>(
-  _ fn: (In) -> Out, useXLA: Bool = false
+// Trace the given function to generate a TF graph and return a closure that can be used to launch
+// the graph.
+public func _graph<In: TensorGroup, Out: TensorGroup>(
+    _ fn: (In) -> Out,
+    useXLA: Bool = false
 ) -> (In) -> Out {
-  let traceContext: TraceContext = withoutActuallyEscaping(fn) { escapableFn in
-    let wrappedFn = { (inputs: [CTensorHandle]) -> [CTensorHandle] in
-      let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(
-        capacity: Int(inputs.count))
-      var ptr = buffer
-      for input in inputs {
-        ptr.initialize(to: input)
-        ptr = ptr.advanced(by: 1)
-      }
-      let symbolicIn = In(_owning: buffer)
-      let symbolicOut = escapableFn(symbolicIn)
-      return symbolicOut.cTensorHandles
-    }
-    let dtypes = In._typeList.map { $0._cDataType }
-    return _trace(with: dtypes, in: wrappedFn)
-  }
-  // The result is a closure that captures and executes the trace graph
-  // function in the trace context.
-  return { (input: In) -> (Out) in
-    debugLog("Running trace function over input \(input).")
-
-    debugLog("Getting input state tensor handles.")
-    let inputStateTensorHandles =  input.cTensorHandles
-    let inputTensors = inputStateTensorHandles.map {
-      TFETensorHandle(_owning: $0)
+    let traceContext: TraceContext = withoutActuallyEscaping(fn) { escapableFn in
+        let wrappedFn = { (inputs: [CTensorHandle]) -> [CTensorHandle] in
+            let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(capacity: Int(inputs.count))
+            var ptr = buffer
+            for input in inputs {
+                ptr.initialize(to: input)
+                ptr = ptr.advanced(by: 1)
+            }
+            let symbolicIn = In(_owning: buffer)
+            let symbolicOut = escapableFn(symbolicIn)
+            return symbolicOut.cTensorHandles
+        }
+        let dtypes = In._typeList.map { $0._cDataType }
+        return _trace(with: dtypes, in: wrappedFn)
     }
-    debugLog("Executing trace graph function.")
-    let returnValues = traceContext.execute(
-      traceeInputs: inputTensors, useXLA: useXLA)
+    // The result is a closure that captures and executes the trace graph function in the trace
+    // context.
+    return { (input: In) -> (Out) in
+        debugLog("Running trace function over input \(input).")
+
+        debugLog("Getting input state tensor handles.")
+        let inputStateTensorHandles =  input.cTensorHandles
+        let inputTensors = inputStateTensorHandles.map {
+            TFETensorHandle(_owning: $0)
+        }
+        debugLog("Executing trace graph function.")
+        let returnValues = traceContext.execute(traceeInputs: inputTensors, useXLA: useXLA)
 
-    debugLog("Creating output model instance.")
-    return Out(_owning: returnValues)
-  }
+        debugLog("Creating output model instance.")
+        return Out(_owning: returnValues)
+    }
 }
 
-/// Trace the given function and return the name of the corresponding
-/// `TF_Function: In -> Out` that was created.
-public func _tffunc<In : TensorGroup, Out : TensorGroup>(
-  _ fn: (In) -> Out
-) -> String {
-  let traceContext: TraceContext = withoutActuallyEscaping(fn) { escapableFn in
-    let wrappedFn = {
-      (inputs: [CTensorHandle]) -> [CTensorHandle] in
-      let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(
-        capacity: Int(inputs.count))
-      var ptr = buffer
-      for input in inputs {
-        ptr.initialize(to: input)
-        ptr = ptr.advanced(by: 1)
-      }
-      let symbolicIn = In(_owning: buffer)
-      let symbolicOut = escapableFn(symbolicIn)
-      return symbolicOut.cTensorHandles
+/// Trace the given function and return the name of the corresponding `TF_Function: In -> Out` that
+/// was created.
+public func _tffunc<In: TensorGroup, Out: TensorGroup>(_ fn: (In) -> Out) -> String {
+    let traceContext: TraceContext = withoutActuallyEscaping(fn) { escapableFn in
+        let wrappedFn = { (inputs: [CTensorHandle]) -> [CTensorHandle] in
+            let buffer = UnsafeMutablePointer<CTensorHandle>.allocate(capacity: Int(inputs.count))
+            var ptr = buffer
+            for input in inputs {
+                ptr.initialize(to: input)
+                ptr = ptr.advanced(by: 1)
+            }
+            let symbolicIn = In(_owning: buffer)
+            let symbolicOut = escapableFn(symbolicIn)
+            return symbolicOut.cTensorHandles
+        }
+        
+        let dtypes = In._typeList.map { $0._cDataType }
+        return _trace(with: dtypes, in: wrappedFn)
     }
-    
-    let dtypes = In._typeList.map { $0._cDataType }
-    return _trace(with: dtypes, in: wrappedFn)
-  }
-  return traceContext.specializeTFFunction(with: [])
+    return traceContext.specializeTFFunction(with: [])
 }
 
 internal extension _ExecutionContext {
-  /// Returns a valid TensorFlow device name, which corresponds to the
-  /// closest enclosing call to one of the overloads of withDevice.
-  /// A return value of `nil` indicates the absence of a withDevice call on
-  /// the call stack or the presence of an immediately enclosing
-  /// `withDefaultDevice(perform)` call.
-  var currentDeviceName: String? {
-    return _ThreadLocalState.local._currentDevice
-  }
-
-  /// See documentation for the top-level `withDevice(_:_:perform)`.
-  func withDevice<R>(
-    _ kind: DeviceKind,
-    _ index: UInt = 0,
-    perform body: () throws -> R
-  ) rethrows -> R {
-    let name: String
-    switch kind {
-    case .cpu:
-      name = "/job:localhost/replica:0/task:0/device:CPU:\(index)"
-    case .gpu:
-      name = "/job:localhost/replica:0/task:0/device:GPU:\(index)"
-    case .tpu:
-      // According to server def generated when you set
-      // SWIFT_TENSORFLOW_SERVER_ADDRESS, the TPUs will all be on task 1.
-      name = "/job:localhost/replica:0/task:1/device:TPU:\(index)"
+    /// Returns a valid TensorFlow device name, which corresponds to the closest enclosing call to 
+    /// one of the overloads of withDevice. A return value of `nil` indicates the absence of a 
+    /// withDevice call on the call stack or the presence of an immediately enclosing 
+    /// `withDefaultDevice(perform)` call.
+    var currentDeviceName: String? {
+        return _ThreadLocalState.local._currentDevice
+    }
+
+    /// See documentation for the top-level `withDevice(_:_:perform)`.
+    func withDevice<R>(
+        _ kind: DeviceKind,
+        _ index: UInt = 0,
+        perform body: () throws -> R
+    ) rethrows -> R {
+        let name: String
+        switch kind {
+        case .cpu:
+            name = "/job:localhost/replica:0/task:0/device:CPU:\(index)"
+        case .gpu:
+            name = "/job:localhost/replica:0/task:0/device:GPU:\(index)"
+        case .tpu:
+            // According to server def generated when you set
+            // SWIFT_TENSORFLOW_SERVER_ADDRESS, the TPUs will all be on task 1.
+            name = "/job:localhost/replica:0/task:1/device:TPU:\(index)"
+        }
+        return try withDevice(named: name, perform: body)
     }
-    return try withDevice(named: name, perform: body)
-  }
 
-  /// See documentation for the top-level `withDevice(named:perform)`.
-  func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R {
-    guard deviceNames.contains(name) else {
-      fatalError("Device \(name) not found")
+    /// See documentation for the top-level `withDevice(named:perform)`.
+    func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R {
+        guard deviceNames.contains(name) else {
+            fatalError("Device \(name) not found")
+        }
+        _ThreadLocalState.local.pushDevice(name)
+        let result = try body()
+        _ThreadLocalState.local.popDevice()
+        return result
+    }
+
+    /// See documentation for the top-level `withDefaultDevice(perform)`.
+    func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R {
+        _ThreadLocalState.local.pushDevice(nil)
+        let result = try body()
+        _ThreadLocalState.local.popDevice()
+        return result
     }
-    _ThreadLocalState.local.pushDevice(name)
-    let result = try body()
-    _ThreadLocalState.local.popDevice()
-    return result
-  }
-
-  /// See documentation for the top-level `withDefaultDevice(perform)`.
-  func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R {
-    _ThreadLocalState.local.pushDevice(nil)
-    let result = try body()
-    _ThreadLocalState.local.popDevice()
-    return result
-  }
 }
 
 internal extension _ExecutionContext {
-  /// Synchronously execute the body, preventing asynchronous computation from
-  /// corrupting the context data.
-  private func sync<Result>(
-    execute body: () throws -> Result
-  ) rethrows -> Result {
-    let lockStatus = pthread_mutex_lock(&mutex)
-    internalConsistencyCheck(lockStatus == 0)
-    defer {
-      let unlockStatus = pthread_mutex_unlock(&mutex)
-      internalConsistencyCheck(unlockStatus == 0)
-      // Create a cancellation point.
-      pthread_testcancel()
+    /// Synchronously execute the body, preventing asynchronous computation from corrupting the 
+    /// context data.
+    private func sync<Result>(execute body: () throws -> Result) rethrows -> Result {
+        let lockStatus = pthread_mutex_lock(&mutex)
+        internalConsistencyCheck(lockStatus == 0)
+        defer {
+            let unlockStatus = pthread_mutex_unlock(&mutex)
+            internalConsistencyCheck(unlockStatus == 0)
+            // Create a cancellation point.
+            pthread_testcancel()
+        }
+        return try body()
     }
-    return try body()
-  }
 }
 
 @usableFromInline
-internal func dumpTensorContent<Scalar : _TensorFlowDataTypeCompatible>(
-  _ inputTensor: CTensorHandle, _: Scalar.Type
+internal func dumpTensorContent<Scalar: _TensorFlowDataTypeCompatible>(
+  _ inputTensor: CTensorHandle,
+  _: Scalar.Type
 ) {
-  assert(TFE_TensorHandleIsConcrete(inputTensor) != 0)
-
-  let array = ShapedArray<Scalar>(cTensorHandle: inputTensor)
-  debugLog("Rank is \(array.rank), shape is \(array.shape).")
-  debugLog("""
-    The content of the \(array.scalars.count) scalars are: \
-    \(array.scalars).
-    """)
+    assert(TFE_TensorHandleIsConcrete(inputTensor) != 0)
+
+    let array = ShapedArray<Scalar>(cTensorHandle: inputTensor)
+    debugLog("Rank is \(array.rank), shape is \(array.shape).")
+    debugLog("""
+             The content of the \(array.scalars.count) scalars are: \
+             \(array.scalars).
+             """)
 }
 
 @usableFromInline
-internal func dumpCTensorHandleContent(
-  _ idx: Int,
-  _ inputTensorHandle: CTensorHandle) {
-  if TFE_TensorHandleIsConcrete(inputTensorHandle) == 0 {
-    debugLog("Skip dumpping a symbolic tensor handle.")
-    return
-  }
-
-  let dType: TF_DataType = TFE_TensorHandleDataType(inputTensorHandle)
-  debugLog("Tensor \(idx) has TF data type \(dType).")
-  switch dType {
-  case TF_UINT8: dumpTensorContent(inputTensorHandle, UInt8.self)
-  case TF_INT8: dumpTensorContent(inputTensorHandle, Int8.self)
-  case TF_UINT16: dumpTensorContent(inputTensorHandle, UInt16.self)
-  case TF_INT16: dumpTensorContent(inputTensorHandle, Int16.self)
-  case TF_UINT32: dumpTensorContent(inputTensorHandle, UInt32.self)
-  case TF_INT32: dumpTensorContent(inputTensorHandle, Int32.self)
-  case TF_UINT64: dumpTensorContent(inputTensorHandle, UInt64.self)
-  case TF_INT64: dumpTensorContent(inputTensorHandle, Int64.self)
-  case TF_FLOAT: dumpTensorContent(inputTensorHandle, Float.self)
-  case TF_DOUBLE: dumpTensorContent(inputTensorHandle, Double.self)
-  case TF_BOOL: dumpTensorContent(inputTensorHandle, Bool.self)
-  // TODO: Handle `TF_BFloat16`? BFloat16 does not have a host-side
-  // representation and cannot be printed directly. Consider calling into TF
-  // runtime.
-  default: fatalError("Unsupported dtype \(dType)")
-  }
+internal func dumpCTensorHandleContent(_ idx: Int, _ inputTensorHandle: CTensorHandle) {
+    if TFE_TensorHandleIsConcrete(inputTensorHandle) == 0 {
+        debugLog("Skip dumpping a symbolic tensor handle.")
+        return
+    }
+
+    let dType: TF_DataType = TFE_TensorHandleDataType(inputTensorHandle)
+    debugLog("Tensor \(idx) has TF data type \(dType).")
+    switch dType {
+    case TF_UINT8: dumpTensorContent(inputTensorHandle, UInt8.self)
+    case TF_INT8: dumpTensorContent(inputTensorHandle, Int8.self)
+    case TF_UINT16: dumpTensorContent(inputTensorHandle, UInt16.self)
+    case TF_INT16: dumpTensorContent(inputTensorHandle, Int16.self)
+    case TF_UINT32: dumpTensorContent(inputTensorHandle, UInt32.self)
+    case TF_INT32: dumpTensorContent(inputTensorHandle, Int32.self)
+    case TF_UINT64: dumpTensorContent(inputTensorHandle, UInt64.self)
+    case TF_INT64: dumpTensorContent(inputTensorHandle, Int64.self)
+    case TF_FLOAT: dumpTensorContent(inputTensorHandle, Float.self)
+    case TF_DOUBLE: dumpTensorContent(inputTensorHandle, Double.self)
+    case TF_BOOL: dumpTensorContent(inputTensorHandle, Bool.self)
+    // TODO: Handle `TF_BFloat16`? BFloat16 does not have a host-side
+    // representation and cannot be printed directly. Consider calling into TF
+    // runtime.
+    default: fatalError("Unsupported dtype \(dType)")
+    }
 }
 
 @inlinable
 @_cdecl("_swift_tfc_EagerExecute")
-internal func _TFCEagerExecute(_ op: CTFEOp,
-                               _ retvals: UnsafeMutablePointer<OpaquePointer?>,
-                               _ retvalCount: UnsafeMutablePointer<Int32>,
-                               _ status: CTFStatus) {
-  if _RuntimeConfig.printsDebugLog {
-    debugLog("Calling _TFCEagerExecute() over: ")
-    if let value = getenv("TF_CPP_MIN_LOG_LEVEL"),
-      String(cString: value) == "0" {
-      TFE_OpPrintDebugString(op)
+internal func _TFCEagerExecute(
+    _ op: CTFEOp,
+    _ retvals: UnsafeMutablePointer<OpaquePointer?>,
+    _ retvalCount: UnsafeMutablePointer<Int32>,
+    _ status: CTFStatus
+) {
+    if _RuntimeConfig.printsDebugLog {
+        debugLog("Calling _TFCEagerExecute() over: ")
+        if let value = getenv("TF_CPP_MIN_LOG_LEVEL"),
+            String(cString: value) == "0" {
+            TFE_OpPrintDebugString(op)
+        } else {
+            debugLog("[Run with TF_CPP_MIN_LOG_LEVEL=0 to have TFEOps printed out]")
+        }
+    }
+    if let traceContext = _RuntimeConfig.traceState.context {
+        // convert this eager op into a trace graph node
+        debugLog("Adding eager op \(op) to trace graph.")
+        traceContext.addEagerOpToGraph(op, retvals, retvalCount, status)
+        checkOk(status)
     } else {
-      debugLog("[Run with TF_CPP_MIN_LOG_LEVEL=0 to have TFEOps printed out]")
+        debugLog("Executing eager op \(op).")
+        TFE_Execute(op, retvals, retvalCount, status)
+        checkOk(status)
     }
-  }
-  if let traceContext = _RuntimeConfig.traceState.context {
-    // convert this eager op into a trace graph node
-    debugLog("Adding eager op \(op) to trace graph.")
-    traceContext.addEagerOpToGraph(op, retvals, retvalCount, status)
-    checkOk(status)
-  } else {
-    debugLog("Executing eager op \(op).")
-    TFE_Execute(op, retvals, retvalCount, status)
-    checkOk(status)
-  }
 }
 
 //===----------------------------------------------------------------------===//
@@ -1166,160 +1129,159 @@ internal func _TFCEagerExecute(_ op: CTFEOp,
 @usableFromInline
 @_cdecl("_swift_tfc_GetGlobalEagerContext")
 func _TFCGetGlobalEagerContext() -> CTFEContext {
-  debugLog("Calling _GetGlobalEagerContext()")
-  return _ExecutionContext.global.eagerContext
+    debugLog("Calling _GetGlobalEagerContext()")
+    return _ExecutionContext.global.eagerContext
 }
 
-// Some of the functions are marked with @silgen_name instead of @_cdecl,
-// because their input/output data types are not C-compatible
-// (e.g. AnyTensorHandle).
+// Some of the functions are marked with @silgen_name instead of @_cdecl, because their input/output
+// data types are not C-compatible (e.g., AnyTensorHandle).
 
 /// Adds `handle` as an input to `op`.
 @usableFromInline
 @_silgen_name("_swift_tfc_OpAddInputFromTensorHandle")
-func _TFCOpAddInputFromTensorHandle(_ op: CTFEOp,
-                                    _ handle: _AnyTensorHandle,
-                                    _ status: CTFStatus) {
-  TFE_OpAddInput(op, handle._cTensorHandle, status)
+func _TFCOpAddInputFromTensorHandle(_ op: CTFEOp, _ handle: _AnyTensorHandle, _ status: CTFStatus) {
+    TFE_OpAddInput(op, handle._cTensorHandle, status)
 }
 
 /// Adds `t` as an input or inputs to `op`. Returns the number of inputs added.
 @usableFromInline
 @_silgen_name("_swift_tfc_OpAddInputFromTensorGroup")
-func _TFCOpAddInputFromTensorGroup<T : TensorArrayProtocol>(
-    _ op: CTFEOp, _ t: T, _ status: CTFStatus
+func _TFCOpAddInputFromTensorGroup<T: TensorArrayProtocol>(
+    _ op: CTFEOp,
+    _ t: T,
+    _ status: CTFStatus
 ) -> Int32 {
-  let count = t._tensorHandleCount
-  let buffer =
-      UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: Int(count))
-  defer { buffer.deallocate() }
-  t._unpackTensorHandles(into: buffer.baseAddress)
-  for handle in buffer {
-    TFE_OpAddInput(op, handle, status)
-    guard TF_GetCode(status) == TF_OK else {
-      return 0
+    let count = t._tensorHandleCount
+    let buffer = UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: Int(count))
+    defer { buffer.deallocate() }
+    t._unpackTensorHandles(into: buffer.baseAddress)
+    for handle in buffer {
+        TFE_OpAddInput(op, handle, status)
+        guard TF_GetCode(status) == TF_OK else {
+            return 0
+        }
     }
-  }
-  return count
+    return count
 }
 
-/// Special protocol for calling tensorflow operations that take heterogeneous
-/// arrays as input.
+/// Special protocol for calling tensorflow operations that take heterogeneous arrays as input.
 public protocol AnyTensor {
-  var _rawTensorHandle: CTensorHandle { get }
-  var _tensorFlowDataType: TensorDataType { get }
+    var _rawTensorHandle: CTensorHandle { get }
+    var _tensorFlowDataType: TensorDataType { get }
 }
 
 @usableFromInline
-func _TFCOpAddInputFromAnyTensors(
-  _ op: CTFEOp, _ tensors: [AnyTensor], _ status: CTFStatus
-) {
-  for tensor in tensors {
-    let handle = tensor._rawTensorHandle
-    TFE_OpAddInput(op, handle, status)
-    checkOk(status)
-  }
+func _TFCOpAddInputFromAnyTensors(_ op: CTFEOp, _ tensors: [AnyTensor], _ status: CTFStatus) {
+    for tensor in tensors {
+        let handle = tensor._rawTensorHandle
+        TFE_OpAddInput(op, handle, status)
+        checkOk(status)
+    }
 }
 
-// _TFCOpSetAttr*Array functions are wrappers around TFE_OpSetAttr*List
-// functions. The wrappers handle converting the Swift Stdlib Array<T> values
-// into buffers that TFE_OpSetAttr*List functions can read.
+// _TFCOpSetAttr*Array functions are wrappers around TFE_OpSetAttr*List functions. The wrappers
+// handle converting the Swift Stdlib Array<T> values into buffers that TFE_OpSetAttr*List functions
+// can read.
 
 @usableFromInline
 @_silgen_name("_swift_tfc_OpSetAttrTypeArray")
-func _TFCOpSetAttrTypeArray(_ op: CTFEOp,
-                            _ attrName: UnsafePointer<Int8>,
-                            _ value: Array<TensorDataType>) {
-  value.withUnsafeBufferPointer { buffer in
-    buffer.withMemoryRebound(to: TF_DataType.self) { reboundBuffer in
-      TFE_OpSetAttrTypeList(op, attrName, reboundBuffer.baseAddress,
-                            Int32(reboundBuffer.count))
+func _TFCOpSetAttrTypeArray(
+    _ op: CTFEOp,
+    _ attrName: UnsafePointer<Int8>,
+    _ value: Array<TensorDataType>
+) {
+    value.withUnsafeBufferPointer { buffer in
+        buffer.withMemoryRebound(to: TF_DataType.self) { reboundBuffer in
+            TFE_OpSetAttrTypeList(
+                op, attrName, reboundBuffer.baseAddress, Int32(reboundBuffer.count))
+        }
     }
-  }
 }
 
-/// Given dimensions and ranks in the form described below, makes the
-/// appropriate call to `TFE_OpSetAttrShapeList(op, attrName, ..., status)`.
+/// Given dimensions and ranks in the form described below, makes the appropriate call to 
+/// `TFE_OpSetAttrShapeList(op, attrName, ..., status)`.
 ///
 /// - Parameters
-///   - flattenedDims: all the shapes' dimensions concatenated together in
-///     order
-///   - ranks: all the shapes' ranks (-1 denotes unknown rank)
+///   - flattenedDims: all the shapes' dimensions concatenated together in order.
+///   - ranks: all the shapes' ranks (-1 denotes unknown rank).
 fileprivate func setAttrShapeList(
-  op: CTFEOp, attrName: UnsafePointer<Int8>, flattenedDims: Array<Int64>,
-  ranks: Array<Int32>, status: CTFStatus
+    op: CTFEOp,
+    attrName: UnsafePointer<Int8>,
+    flattenedDims: Array<Int64>,
+    ranks: Array<Int32>,
+    status: CTFStatus
 ) {
-  flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
-    var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
-    var dims: [UnsafePointer<Int64>?] = []
-    for rank in ranks {
-      dims.append(dimsPtr)
-      if rank >= 0 {
-        dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
-      }
-    }
-    dims.withUnsafeMutableBufferPointer { dimsBuffer in
-      ranks.withUnsafeBufferPointer { ranksBuffer in
-        TFE_OpSetAttrShapeList(op, attrName, dimsBuffer.baseAddress,
-                               ranksBuffer.baseAddress,
-                               Int32(ranksBuffer.count), status)
-      }
+    flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
+        var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
+        var dims: [UnsafePointer<Int64>?] = []
+        for rank in ranks {
+            dims.append(dimsPtr)
+            if rank >= 0 {
+                dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
+            }
+        }
+        dims.withUnsafeMutableBufferPointer { dimsBuffer in
+            ranks.withUnsafeBufferPointer { ranksBuffer in
+                TFE_OpSetAttrShapeList(
+                    op, attrName, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
+                    Int32(ranksBuffer.count), status)
+            }
+        }
     }
-  }
 }
 
-/// Stack of devices that models nested calls to withDevice/withDefaultDevice.
-/// Devices are represented by their names in TensorFlow notation.
-/// See documentation for `withDevice(named:perform:)` to learn about device names.
+/// Stack of devices that models nested calls to withDevice/withDefaultDevice. Devices are
+/// represented by their names in TensorFlow notation. See documentation for 
+/// `withDevice(named:perform:)` to learn about device names.
 ///
-/// All TensorFlow operations will be put on the topmost device on the stack.
-/// When the stack is empty or the topmost device is `nil`, that allows
-/// TensorFlow to place operations on any device that it sees fit.
+/// All TensorFlow operations will be put on the topmost device on the stack. When the stack is 
+/// empty or the topmost device is `nil`, that allows TensorFlow to place operations on any device
+/// that it sees fit.
 @usableFromInline
 class _ThreadLocalState {
-  var deviceScopes: [String?] = []
+    var deviceScopes: [String?] = []
 
-  private static let key: pthread_key_t = {
-    var key = pthread_key_t()
-    pthread_key_create(&key) {
+    private static let key: pthread_key_t = {
+        var key = pthread_key_t()
+        pthread_key_create(&key) {
 #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
-      let _: AnyObject = Unmanaged.fromOpaque($0).takeRetainedValue()
+            let _: AnyObject = Unmanaged.fromOpaque($0).takeRetainedValue()
 #else
-      let _: AnyObject = Unmanaged.fromOpaque($0!).takeRetainedValue()
+            let _: AnyObject = Unmanaged.fromOpaque($0!).takeRetainedValue()
 #endif
+        }
+        return key
+    }()
+
+    var _currentDevice: String? {
+        return deviceScopes.last ?? nil
+    }
+
+    @usableFromInline
+    func pushDevice(_ device: String?) {
+        deviceScopes.append(device)
     }
-    return key
-  }()
-
-  var _currentDevice: String? {
-    return deviceScopes.last ?? nil
-  }
-
-  @usableFromInline
-  func pushDevice(_ device: String?) {
-    deviceScopes.append(device)
-  }
-
-  @usableFromInline
-  func popDevice() {
-    internalConsistencyCheck(deviceScopes.popLast() != nil)
-  }
-
-  @usableFromInline
-  static var local: _ThreadLocalState {
-    if let state = pthread_getspecific(key) {
-      return Unmanaged.fromOpaque(state).takeUnretainedValue()
+
+    @usableFromInline
+    func popDevice() {
+        internalConsistencyCheck(deviceScopes.popLast() != nil)
+    }
+
+    @usableFromInline
+    static var local: _ThreadLocalState {
+        if let state = pthread_getspecific(key) {
+            return Unmanaged.fromOpaque(state).takeUnretainedValue()
+        }
+        let state = _ThreadLocalState()
+        pthread_setspecific(key, Unmanaged.passRetained(state).toOpaque())
+        return state
     }
-    let state = _ThreadLocalState()
-    pthread_setspecific(key, Unmanaged.passRetained(state).toOpaque())
-    return state
-  }
 }
 
 @usableFromInline
 @_cdecl("_swift_tfc_OpSetDeviceFromScope")
 func _TFCOpSetDeviceFromScope(_ op: CTFEOp, _ status: CTFStatus) {
-  if let deviceName = _ExecutionContext.global.currentDeviceName {
-    TFE_OpSetDevice(op, deviceName, status)
-  }
+    if let deviceName = _ExecutionContext.global.currentDeviceName {
+        TFE_OpSetDevice(op, deviceName, status)
+    }
 }

From 92a3a0caf974624ee7b4992b1b23307d8118477e Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Tue, 28 May 2019 18:22:55 -0400
Subject: [PATCH 52/55] Added back the bindings code.

---
 .gitignore                                    |     1 -
 .../TensorFlow/Bindings/EagerExecution.swift  |   560 +
 .../Bindings/EagerExecution.swift.gyb         |   321 +
 Sources/TensorFlow/Bindings/README.md         |    27 +
 .../TensorFlow/Bindings/RawOpsGenerated.swift | 36738 ++++++++++++++++
 .../Bindings/TFTensorOperation.swift          |   149 +
 .../TensorFlow/Bindings/generate_wrappers.py  |   716 +
 clone_tensorflow_bindings.sh                  |     3 -
 8 files changed, 38511 insertions(+), 4 deletions(-)
 create mode 100644 Sources/TensorFlow/Bindings/EagerExecution.swift
 create mode 100644 Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
 create mode 100644 Sources/TensorFlow/Bindings/README.md
 create mode 100644 Sources/TensorFlow/Bindings/RawOpsGenerated.swift
 create mode 100644 Sources/TensorFlow/Bindings/TFTensorOperation.swift
 create mode 100644 Sources/TensorFlow/Bindings/generate_wrappers.py
 delete mode 100755 clone_tensorflow_bindings.sh

diff --git a/.gitignore b/.gitignore
index f68ac894b..567f66548 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,7 +5,6 @@ xcuserdata
 DerivedData/
 *.xcodeproj
 *~
-Sources/TensorFlow/Bindings
 
 ### MacOS ###
 .DS_Store
diff --git a/Sources/TensorFlow/Bindings/EagerExecution.swift b/Sources/TensorFlow/Bindings/EagerExecution.swift
new file mode 100644
index 000000000..aa0c94c12
--- /dev/null
+++ b/Sources/TensorFlow/Bindings/EagerExecution.swift
@@ -0,0 +1,560 @@
+// !!! THIS CODE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND !!!
+//
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+import CTensorFlow
+
+/// **WARNING:** After constructing a `TFE_Op`, any one of its `execute` methods must be called
+/// *exactly once*. If not called, then a memory leak is introduced due to the underlying TensorFlow
+/// eager op object not being freed. If called more than once, then a SEGFAULT may occur due to
+/// trying to execute a TensorFlow eager op that has already been freed.
+@usableFromInline
+internal struct TFE_Op: TFTensorOperation {
+    @usableFromInline internal let status: CTFStatus
+    @usableFromInline internal let op: CTFEOp
+    @usableFromInline internal let outputCount: Int
+
+    @usableFromInline
+    internal init(_ name: String, _ outputCount: Int) {
+        self.status = TF_NewStatus()
+        self.op = TFE_NewOp(_ExecutionContext.global.eagerContext, name, status)
+        self.outputCount = outputCount
+    }
+
+    @inlinable @inline(__always)
+    internal func addInput(_ input: _AnyTensorHandle) {
+        TFE_OpAddInput(op, input._cTensorHandle, status)
+        checkOk(status)
+    }
+
+    @inlinable @inline(__always)
+    internal func addInput<Scalar: TensorFlowScalar>(_ input: Tensor<Scalar>) {
+        TFE_OpAddInput(op, input.handle._cTensorHandle, status)
+        checkOk(status)
+    }
+
+    @inlinable @inline(__always)
+    internal func addInput(_ input: StringTensor) {
+        TFE_OpAddInput(op, input.handle._cTensorHandle, status)
+        checkOk(status)
+    }
+
+    @inlinable @inline(__always)
+    internal func addInput(_ input: ResourceHandle) {
+        TFE_OpAddInput(op, input._cTensorHandle, status)
+        checkOk(status)
+    }
+
+    @inlinable @inline(__always)
+    internal func addInput(_ input: VariantHandle) {
+        TFE_OpAddInput(op, input._cTensorHandle, status)
+        checkOk(status)
+    }
+
+    @inlinable @inline(__always)
+    internal func addInputList<T: TensorArrayProtocol>(_ input: T) {
+        let count = input._tensorHandleCount
+        var buffer = UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: Int(count))
+        defer { buffer.deallocate() }
+        let pointer = UnsafeMutablePointer<OpaquePointer?>(buffer.baseAddress)
+        input._unpackTensorHandles(into: buffer.baseAddress)
+        TFE_OpAddInputList(op, pointer, count, status)
+        // TODO: checkOk(status)
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: Bool) {
+        TFE_OpSetAttrBool(op, name, value ? 1 : 0)
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: Int) {
+        TFE_OpSetAttrInt(op, name, Int64(value))
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: Int32) {
+        TFE_OpSetAttrInt(op, name, Int64(value))
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: Int64) {
+        TFE_OpSetAttrInt(op, name, value)
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: Float) {
+        TFE_OpSetAttrFloat(op, name, value)
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: Double) {
+        TFE_OpSetAttrFloat(op, name, Float(value))
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: String) {
+        value.utf8CString.withUnsafeBufferPointer { buffer in
+            // utf8CString is null-terminated; TFE_OpSetAttrString wants non-null-terminated.
+            TFE_OpSetAttrString(op, name, buffer.baseAddress, buffer.count - 1)
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: TensorDataType) {
+        TFE_OpSetAttrType(op, name, value._cDataType)
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: TensorShape) {
+        let dimensions: [Int64] = value.dimensions.map(Int64.init)
+        dimensions.withUnsafeBufferPointer { buffer in
+            TFE_OpSetAttrShape(op, name, buffer.baseAddress, Int32(buffer.count), status)
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: TensorShape?) {
+        guard let shape = value else {
+            TFE_OpSetAttrShape(op, name, nil, -1, status)
+            return
+        }
+        updateAttribute(name, shape)
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [Bool]) {
+        value.map({ $0 ? UInt8(1) : UInt8(0) }).withUnsafeBufferPointer { buffer in
+            TFE_OpSetAttrBoolList(op, name, buffer.baseAddress, Int32(buffer.count))
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [Int]) {
+        updateAttribute(name, value.map(Int64.init))
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [Int32]) {
+        updateAttribute(name, value.map(Int64.init))
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [Int64]) {
+        value.withUnsafeBufferPointer { buffer in
+            TFE_OpSetAttrIntList(op, name, buffer.baseAddress, Int32(buffer.count))
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [Float]) {
+        value.withUnsafeBufferPointer { buffer in
+            TFE_OpSetAttrFloatList(op, name, buffer.baseAddress, Int32(buffer.count))
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [Double]) {
+        updateAttribute(name, value.map(Float.init))
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [String]) {
+        // Collect all the strings' utf8 bytes into a single array so that we can
+        // address all the strings with a single
+        // `flattenedStringBytes.withUnsafeBufferPointer`.
+        var flattenedStringBytes: [CChar] = []
+        var lengths: [Int] = []
+        for string in value {
+            // Don't include the null-terminator because TFE_OpSetAttrStringList uses
+            // lengths instead of null-terminators.
+            let stringBytes = string.utf8CString.dropLast()
+            flattenedStringBytes.append(contentsOf: stringBytes)
+            lengths.append(stringBytes.count)
+        }
+
+        // Calculate the addresses of all the strings within our single buffer, and then call
+        // TFE_OpSetAttrStringList.
+        flattenedStringBytes.withUnsafeBufferPointer { flattenedStringBytesBuffer in
+            var stringAddrs: [UnsafeRawPointer?] = []
+            var currentStringAddr = 
+                flattenedStringBytesBuffer.baseAddress.map(UnsafeRawPointer.init)
+            for length in lengths {
+                stringAddrs.append(currentStringAddr)
+                currentStringAddr = currentStringAddr?.advanced(by: length)
+            }
+
+            stringAddrs.withUnsafeBufferPointer { stringAddrsBuffer in
+                lengths.withUnsafeBufferPointer { lengthsBuffer in
+                    TFE_OpSetAttrStringList(op, name, stringAddrsBuffer.baseAddress,
+                        lengthsBuffer.baseAddress, Int32(value.count))
+                }
+            }
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [TensorDataType]) {
+        value.withUnsafeBufferPointer { buffer in
+            buffer.withMemoryRebound(to: TF_DataType.self) { reboundBuffer in
+                TFE_OpSetAttrTypeList(
+                    op, name, reboundBuffer.baseAddress, Int32(reboundBuffer.count))
+            }
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [TensorShape]) {
+        let flattenedDims = value.flatMap { $0.dimensions.map(Int64.init) }
+        let ranks = value.map { Int32($0.rank) }
+        flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
+            var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
+            var dims: [UnsafePointer<Int64>?] = []
+            for rank in ranks {
+                dims.append(dimsPtr)
+                if rank >= 0 {
+                    dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
+                }
+            }
+            dims.withUnsafeMutableBufferPointer { dimsBuffer in
+                ranks.withUnsafeBufferPointer { ranksBuffer in
+                    TFE_OpSetAttrShapeList(
+                        op, name, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
+                        Int32(ranksBuffer.count), status)
+                }
+            }
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [TensorShape?]) {
+        let flattenedDims = value.flatMap { (tensorShapeOpt) -> [Int64] in
+            if let tensorShape = tensorShapeOpt {
+                return tensorShape.dimensions.map(Int64.init)
+            }
+            return []
+        }
+        let ranks = value.map { shape in (shape?.rank).map(Int32.init) ?? -1 }
+        flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
+            var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
+            var dims: [UnsafePointer<Int64>?] = []
+            for rank in ranks {
+                dims.append(dimsPtr)
+                if rank >= 0 {
+                    dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
+                }
+            }
+            dims.withUnsafeMutableBufferPointer { dimsBuffer in
+                ranks.withUnsafeBufferPointer { ranksBuffer in
+                    TFE_OpSetAttrShapeList(
+                        op, name, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
+                        Int32(ranksBuffer.count), status)
+                }
+            }
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute<In: TensorGroup, Out: TensorGroup>(
+        _ name: String,
+        _ value: (In) -> Out
+    ) {
+        _tffunc(value).utf8CString.withUnsafeBufferPointer { buffer in
+            // utf8CString is null-terminated; TFE_OpSetAttrFunctionName wants
+            // non-null-terminated.
+            TFE_OpSetAttrFunctionName(op, name, buffer.baseAddress, buffer.count - 1)
+        }
+    }
+
+    /// **WARNING:** After constructing a `TFE_Op`, any one of its `execute` methods must be called
+    /// *exactly once*. If not called, then a memory leak is introduced due to the underlying
+    /// TensorFlow eager op object not being freed. If called more than once, then a SEGFAULT may
+    /// occur due to trying to execute a TensorFlow eager op that has already been freed.
+
+    @inlinable @inline(__always)
+    internal func evaluateUnsafe() -> UnsafeMutablePointer<CTensorHandle> {
+        var count: Int32 = Int32(self.outputCount)
+        let buffer: UnsafeMutablePointer<CTensorHandle> =
+        UnsafeMutablePointer.allocate(capacity: Int(count))
+        _TFCOpSetDeviceFromScope(op, status)
+        checkOk(status)
+        _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+        checkOk(status)
+        TFE_DeleteOp(op)
+        TF_DeleteStatus(status)
+        return buffer
+    }
+
+    @inlinable @inline(__always)
+    internal func execute() {
+        let _ = evaluateUnsafe()
+    }
+
+    @inlinable @inline(__always)
+    internal func execute<T0: TensorArrayProtocol>(
+        _ count0: Int
+    ) -> (T0) {
+        let buffer = evaluateUnsafe()
+        let offset0 = Int32(0)
+        let result = (
+            T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0))
+        buffer.deallocate()
+        return result
+    }
+
+    @inlinable @inline(__always)
+    internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int
+    ) -> (T0, T1) {
+        let buffer = evaluateUnsafe()
+        let offset0 = Int32(0)
+        let offset1 = offset0 + Int32(count0)
+        let result = (
+            T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+            T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1))
+        buffer.deallocate()
+        return result
+    }
+
+    @inlinable @inline(__always)
+    internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int
+    ) -> (T0, T1, T2) {
+        let buffer = evaluateUnsafe()
+        let offset0 = Int32(0)
+        let offset1 = offset0 + Int32(count0)
+        let offset2 = offset1 + Int32(count1)
+        let result = (
+            T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+            T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+            T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2))
+        buffer.deallocate()
+        return result
+    }
+
+    @inlinable @inline(__always)
+    internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int
+    ) -> (T0, T1, T2, T3) {
+        let buffer = evaluateUnsafe()
+        let offset0 = Int32(0)
+        let offset1 = offset0 + Int32(count0)
+        let offset2 = offset1 + Int32(count1)
+        let offset3 = offset2 + Int32(count2)
+        let result = (
+            T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+            T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+            T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+            T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3))
+        buffer.deallocate()
+        return result
+    }
+
+    @inlinable @inline(__always)
+    internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int,
+        _ count4: Int
+    ) -> (T0, T1, T2, T3, T4) {
+        let buffer = evaluateUnsafe()
+        let offset0 = Int32(0)
+        let offset1 = offset0 + Int32(count0)
+        let offset2 = offset1 + Int32(count1)
+        let offset3 = offset2 + Int32(count2)
+        let offset4 = offset3 + Int32(count3)
+        let result = (
+            T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+            T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+            T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+            T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
+            T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4))
+        buffer.deallocate()
+        return result
+    }
+
+    @inlinable @inline(__always)
+    internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int,
+        _ count4: Int,
+        _ count5: Int
+    ) -> (T0, T1, T2, T3, T4, T5) {
+        let buffer = evaluateUnsafe()
+        let offset0 = Int32(0)
+        let offset1 = offset0 + Int32(count0)
+        let offset2 = offset1 + Int32(count1)
+        let offset3 = offset2 + Int32(count2)
+        let offset4 = offset3 + Int32(count3)
+        let offset5 = offset4 + Int32(count4)
+        let result = (
+            T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+            T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+            T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+            T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
+            T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
+            T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5))
+        buffer.deallocate()
+        return result
+    }
+
+    @inlinable @inline(__always)
+    internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int,
+        _ count4: Int,
+        _ count5: Int,
+        _ count6: Int
+    ) -> (T0, T1, T2, T3, T4, T5, T6) {
+        let buffer = evaluateUnsafe()
+        let offset0 = Int32(0)
+        let offset1 = offset0 + Int32(count0)
+        let offset2 = offset1 + Int32(count1)
+        let offset3 = offset2 + Int32(count2)
+        let offset4 = offset3 + Int32(count3)
+        let offset5 = offset4 + Int32(count4)
+        let offset6 = offset5 + Int32(count5)
+        let result = (
+            T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+            T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+            T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+            T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
+            T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
+            T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5),
+            T6.init(_owning: buffer.advanced(by: Int(offset6)), count: count6))
+        buffer.deallocate()
+        return result
+    }
+
+    @inlinable @inline(__always)
+    internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol, T7: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int,
+        _ count4: Int,
+        _ count5: Int,
+        _ count6: Int,
+        _ count7: Int
+    ) -> (T0, T1, T2, T3, T4, T5, T6, T7) {
+        let buffer = evaluateUnsafe()
+        let offset0 = Int32(0)
+        let offset1 = offset0 + Int32(count0)
+        let offset2 = offset1 + Int32(count1)
+        let offset3 = offset2 + Int32(count2)
+        let offset4 = offset3 + Int32(count3)
+        let offset5 = offset4 + Int32(count4)
+        let offset6 = offset5 + Int32(count5)
+        let offset7 = offset6 + Int32(count6)
+        let result = (
+            T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+            T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+            T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+            T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
+            T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
+            T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5),
+            T6.init(_owning: buffer.advanced(by: Int(offset6)), count: count6),
+            T7.init(_owning: buffer.advanced(by: Int(offset7)), count: count7))
+        buffer.deallocate()
+        return result
+    }
+
+    @inlinable @inline(__always)
+    internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol, T7: TensorArrayProtocol, T8: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int,
+        _ count4: Int,
+        _ count5: Int,
+        _ count6: Int,
+        _ count7: Int,
+        _ count8: Int
+    ) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8) {
+        let buffer = evaluateUnsafe()
+        let offset0 = Int32(0)
+        let offset1 = offset0 + Int32(count0)
+        let offset2 = offset1 + Int32(count1)
+        let offset3 = offset2 + Int32(count2)
+        let offset4 = offset3 + Int32(count3)
+        let offset5 = offset4 + Int32(count4)
+        let offset6 = offset5 + Int32(count5)
+        let offset7 = offset6 + Int32(count6)
+        let offset8 = offset7 + Int32(count7)
+        let result = (
+            T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+            T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+            T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+            T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
+            T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
+            T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5),
+            T6.init(_owning: buffer.advanced(by: Int(offset6)), count: count6),
+            T7.init(_owning: buffer.advanced(by: Int(offset7)), count: count7),
+            T8.init(_owning: buffer.advanced(by: Int(offset8)), count: count8))
+        buffer.deallocate()
+        return result
+    }
+
+    @inlinable @inline(__always)
+    internal func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol, T7: TensorArrayProtocol, T8: TensorArrayProtocol, T9: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int,
+        _ count4: Int,
+        _ count5: Int,
+        _ count6: Int,
+        _ count7: Int,
+        _ count8: Int,
+        _ count9: Int
+    ) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {
+        let buffer = evaluateUnsafe()
+        let offset0 = Int32(0)
+        let offset1 = offset0 + Int32(count0)
+        let offset2 = offset1 + Int32(count1)
+        let offset3 = offset2 + Int32(count2)
+        let offset4 = offset3 + Int32(count3)
+        let offset5 = offset4 + Int32(count4)
+        let offset6 = offset5 + Int32(count5)
+        let offset7 = offset6 + Int32(count6)
+        let offset8 = offset7 + Int32(count7)
+        let offset9 = offset8 + Int32(count8)
+        let result = (
+            T0.init(_owning: buffer.advanced(by: Int(offset0)), count: count0),
+            T1.init(_owning: buffer.advanced(by: Int(offset1)), count: count1),
+            T2.init(_owning: buffer.advanced(by: Int(offset2)), count: count2),
+            T3.init(_owning: buffer.advanced(by: Int(offset3)), count: count3),
+            T4.init(_owning: buffer.advanced(by: Int(offset4)), count: count4),
+            T5.init(_owning: buffer.advanced(by: Int(offset5)), count: count5),
+            T6.init(_owning: buffer.advanced(by: Int(offset6)), count: count6),
+            T7.init(_owning: buffer.advanced(by: Int(offset7)), count: count7),
+            T8.init(_owning: buffer.advanced(by: Int(offset8)), count: count8),
+            T9.init(_owning: buffer.advanced(by: Int(offset9)), count: count9))
+        buffer.deallocate()
+        return result
+    }
+
+}
diff --git a/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb b/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
new file mode 100644
index 000000000..75cf2d549
--- /dev/null
+++ b/Sources/TensorFlow/Bindings/EagerExecution.swift.gyb
@@ -0,0 +1,321 @@
+// !!! THIS CODE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND !!!
+//
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+import CTensorFlow
+
+/// **WARNING:** After constructing a `TFE_Op`, any one of its `execute` methods must be called
+/// *exactly once*. If not called, then a memory leak is introduced due to the underlying TensorFlow
+/// eager op object not being freed. If called more than once, then a SEGFAULT may occur due to
+/// trying to execute a TensorFlow eager op that has already been freed.
+@usableFromInline
+internal struct TFE_Op: TFTensorOperation {
+    @usableFromInline internal let status: CTFStatus
+    @usableFromInline internal let op: CTFEOp
+    @usableFromInline internal let outputCount: Int
+
+    @usableFromInline
+    internal init(_ name: String, _ outputCount: Int) {
+        self.status = TF_NewStatus()
+        self.op = TFE_NewOp(_ExecutionContext.global.eagerContext, name, status)
+        self.outputCount = outputCount
+    }
+
+    @inlinable @inline(__always)
+    internal func addInput(_ input: _AnyTensorHandle) {
+        TFE_OpAddInput(op, input._cTensorHandle, status)
+        checkOk(status)
+    }
+
+    @inlinable @inline(__always)
+    internal func addInput<Scalar: TensorFlowScalar>(_ input: Tensor<Scalar>) {
+        TFE_OpAddInput(op, input.handle._cTensorHandle, status)
+        checkOk(status)
+    }
+
+    @inlinable @inline(__always)
+    internal func addInput(_ input: StringTensor) {
+        TFE_OpAddInput(op, input.handle._cTensorHandle, status)
+        checkOk(status)
+    }
+
+    @inlinable @inline(__always)
+    internal func addInput(_ input: ResourceHandle) {
+        TFE_OpAddInput(op, input._cTensorHandle, status)
+        checkOk(status)
+    }
+
+    @inlinable @inline(__always)
+    internal func addInput(_ input: VariantHandle) {
+        TFE_OpAddInput(op, input._cTensorHandle, status)
+        checkOk(status)
+    }
+
+    @inlinable @inline(__always)
+    internal func addInputList<T: TensorArrayProtocol>(_ input: T) {
+        let count = input._tensorHandleCount
+        var buffer = UnsafeMutableBufferPointer<CTensorHandle>.allocate(capacity: Int(count))
+        defer { buffer.deallocate() }
+        let pointer = UnsafeMutablePointer<OpaquePointer?>(buffer.baseAddress)
+        input._unpackTensorHandles(into: buffer.baseAddress)
+        TFE_OpAddInputList(op, pointer, count, status)
+        // TODO: checkOk(status)
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: Bool) {
+        TFE_OpSetAttrBool(op, name, value ? 1 : 0)
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: Int) {
+        TFE_OpSetAttrInt(op, name, Int64(value))
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: Int32) {
+        TFE_OpSetAttrInt(op, name, Int64(value))
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: Int64) {
+        TFE_OpSetAttrInt(op, name, value)
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: Float) {
+        TFE_OpSetAttrFloat(op, name, value)
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: Double) {
+        TFE_OpSetAttrFloat(op, name, Float(value))
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: String) {
+        value.utf8CString.withUnsafeBufferPointer { buffer in
+            // utf8CString is null-terminated; TFE_OpSetAttrString wants non-null-terminated.
+            TFE_OpSetAttrString(op, name, buffer.baseAddress, buffer.count - 1)
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: TensorDataType) {
+        TFE_OpSetAttrType(op, name, value._cDataType)
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: TensorShape) {
+        let dimensions: [Int64] = value.dimensions.map(Int64.init)
+        dimensions.withUnsafeBufferPointer { buffer in
+            TFE_OpSetAttrShape(op, name, buffer.baseAddress, Int32(buffer.count), status)
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: TensorShape?) {
+        guard let shape = value else {
+            TFE_OpSetAttrShape(op, name, nil, -1, status)
+            return
+        }
+        updateAttribute(name, shape)
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [Bool]) {
+        value.map({ $0 ? UInt8(1) : UInt8(0) }).withUnsafeBufferPointer { buffer in
+            TFE_OpSetAttrBoolList(op, name, buffer.baseAddress, Int32(buffer.count))
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [Int]) {
+        updateAttribute(name, value.map(Int64.init))
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [Int32]) {
+        updateAttribute(name, value.map(Int64.init))
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [Int64]) {
+        value.withUnsafeBufferPointer { buffer in
+            TFE_OpSetAttrIntList(op, name, buffer.baseAddress, Int32(buffer.count))
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [Float]) {
+        value.withUnsafeBufferPointer { buffer in
+            TFE_OpSetAttrFloatList(op, name, buffer.baseAddress, Int32(buffer.count))
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [Double]) {
+        updateAttribute(name, value.map(Float.init))
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [String]) {
+        // Collect all the strings' utf8 bytes into a single array so that we can
+        // address all the strings with a single
+        // `flattenedStringBytes.withUnsafeBufferPointer`.
+        var flattenedStringBytes: [CChar] = []
+        var lengths: [Int] = []
+        for string in value {
+            // Don't include the null-terminator because TFE_OpSetAttrStringList uses
+            // lengths instead of null-terminators.
+            let stringBytes = string.utf8CString.dropLast()
+            flattenedStringBytes.append(contentsOf: stringBytes)
+            lengths.append(stringBytes.count)
+        }
+
+        // Calculate the addresses of all the strings within our single buffer, and then call
+        // TFE_OpSetAttrStringList.
+        flattenedStringBytes.withUnsafeBufferPointer { flattenedStringBytesBuffer in
+            var stringAddrs: [UnsafeRawPointer?] = []
+            var currentStringAddr = 
+                flattenedStringBytesBuffer.baseAddress.map(UnsafeRawPointer.init)
+            for length in lengths {
+                stringAddrs.append(currentStringAddr)
+                currentStringAddr = currentStringAddr?.advanced(by: length)
+            }
+
+            stringAddrs.withUnsafeBufferPointer { stringAddrsBuffer in
+                lengths.withUnsafeBufferPointer { lengthsBuffer in
+                    TFE_OpSetAttrStringList(op, name, stringAddrsBuffer.baseAddress,
+                        lengthsBuffer.baseAddress, Int32(value.count))
+                }
+            }
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [TensorDataType]) {
+        value.withUnsafeBufferPointer { buffer in
+            buffer.withMemoryRebound(to: TF_DataType.self) { reboundBuffer in
+                TFE_OpSetAttrTypeList(
+                    op, name, reboundBuffer.baseAddress, Int32(reboundBuffer.count))
+            }
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [TensorShape]) {
+        let flattenedDims = value.flatMap { $0.dimensions.map(Int64.init) }
+        let ranks = value.map { Int32($0.rank) }
+        flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
+            var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
+            var dims: [UnsafePointer<Int64>?] = []
+            for rank in ranks {
+                dims.append(dimsPtr)
+                if rank >= 0 {
+                    dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
+                }
+            }
+            dims.withUnsafeMutableBufferPointer { dimsBuffer in
+                ranks.withUnsafeBufferPointer { ranksBuffer in
+                    TFE_OpSetAttrShapeList(
+                        op, name, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
+                        Int32(ranksBuffer.count), status)
+                }
+            }
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute(_ name: String, _ value: [TensorShape?]) {
+        let flattenedDims = value.flatMap { (tensorShapeOpt) -> [Int64] in
+            if let tensorShape = tensorShapeOpt {
+                return tensorShape.dimensions.map(Int64.init)
+            }
+            return []
+        }
+        let ranks = value.map { shape in (shape?.rank).map(Int32.init) ?? -1 }
+        flattenedDims.withUnsafeBufferPointer { flattenedDimsBuffer in
+            var dimsPtr: UnsafePointer<Int64>? = flattenedDimsBuffer.baseAddress
+            var dims: [UnsafePointer<Int64>?] = []
+            for rank in ranks {
+                dims.append(dimsPtr)
+                if rank >= 0 {
+                    dimsPtr = dimsPtr.map { $0.advanced(by: Int(rank)) }
+                }
+            }
+            dims.withUnsafeMutableBufferPointer { dimsBuffer in
+                ranks.withUnsafeBufferPointer { ranksBuffer in
+                    TFE_OpSetAttrShapeList(
+                        op, name, dimsBuffer.baseAddress, ranksBuffer.baseAddress,
+                        Int32(ranksBuffer.count), status)
+                }
+            }
+        }
+    }
+
+    @inlinable @inline(__always)
+    internal func updateAttribute<In: TensorGroup, Out: TensorGroup>(
+        _ name: String,
+        _ value: (In) -> Out
+    ) {
+        _tffunc(value).utf8CString.withUnsafeBufferPointer { buffer in
+            // utf8CString is null-terminated; TFE_OpSetAttrFunctionName wants
+            // non-null-terminated.
+            TFE_OpSetAttrFunctionName(op, name, buffer.baseAddress, buffer.count - 1)
+        }
+    }
+
+    /// **WARNING:** After constructing a `TFE_Op`, any one of its `execute` methods must be called
+    /// *exactly once*. If not called, then a memory leak is introduced due to the underlying
+    /// TensorFlow eager op object not being freed. If called more than once, then a SEGFAULT may
+    /// occur due to trying to execute a TensorFlow eager op that has already been freed.
+
+    @inlinable @inline(__always)
+    internal func evaluateUnsafe() -> UnsafeMutablePointer<CTensorHandle> {
+        var count: Int32 = Int32(self.outputCount)
+        let buffer: UnsafeMutablePointer<CTensorHandle> =
+        UnsafeMutablePointer.allocate(capacity: Int(count))
+        _TFCOpSetDeviceFromScope(op, status)
+        checkOk(status)
+        _TFCEagerExecute(op, UnsafeMutablePointer<CTensorHandle?>(buffer), &count, status)
+        checkOk(status)
+        TFE_DeleteOp(op)
+        TF_DeleteStatus(status)
+        return buffer
+    }
+
+    @inlinable @inline(__always)
+    internal func execute() {
+        let _ = evaluateUnsafe()
+    }
+
+%for n in range(1, 10 + 1):
+    @inlinable @inline(__always)
+    internal func execute<${", ".join(["T" + str(i) + ": TensorArrayProtocol" for i in range(n)])}>(
+        ${",\n        ".join(["_ count" + str(i) + ": Int" for i in range(n)])}
+    ) -> (${", ".join(["T" + str(i) for i in range(n)])}) {
+        let buffer = evaluateUnsafe()
+%for i in range(n):
+        let offset${i} = ${"Int32(0)" if i == 0 else "offset" + str(i - 1) + " + Int32(count" + str(i - 1) + ")"}
+%end
+        let result = (
+            ${",\n            ".join(["T" + str(i) + ".init(_owning: buffer.advanced(by: Int(offset" + str(i) + ")), count: count" + str(i) + ")" for i in range(n)])})
+        buffer.deallocate()
+        return result
+    }
+
+%end
+}
diff --git a/Sources/TensorFlow/Bindings/README.md b/Sources/TensorFlow/Bindings/README.md
new file mode 100644
index 000000000..2da786ee6
--- /dev/null
+++ b/Sources/TensorFlow/Bindings/README.md
@@ -0,0 +1,27 @@
+# Swift for TensorFlow Ops Bindings
+
+This repository contains TensorFlow ops bindings for
+[Swift for TensorFlow](https://github.com/tensorflow/swift).
+
+These bindings are automatically generated from TensorFlow ops
+specified either using ops registered to the TensorFlow runtime
+or via a protobuf file similar to
+[ops.pbtxt](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/ops/ops.pbtxt)
+in the main TensorFlow repo.
+
+## How to regenerate the bindings
+
+To regenerate the swift ops bindings, run the following command. Note
+that this will use the TensorFlow (1.9 or above) python package.
+
+``` shell
+python generate_wrappers.py --output_path=RawOpsGenerated.swift
+```
+
+Documentation gets automatically generated when adding a path to the
+`api_def` proto directory. This directory should contain per operator
+`api_def` protos with names like `api_def_OpName.pbtxt`.
+
+```shell
+python generate_wrappers.py --output_path=RawOpsGenerated.swift --api_def_path=/path/to/tensorflow/core/api_def/base_api
+```
diff --git a/Sources/TensorFlow/Bindings/RawOpsGenerated.swift b/Sources/TensorFlow/Bindings/RawOpsGenerated.swift
new file mode 100644
index 000000000..3dbf89c99
--- /dev/null
+++ b/Sources/TensorFlow/Bindings/RawOpsGenerated.swift
@@ -0,0 +1,36738 @@
+// !!! THIS CODE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND !!!
+//
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+import CTensorFlow
+
+@inlinable @inline(__always)
+func makeOp(_ name: String, _ nOutputs: Int) -> TFTensorOperation {
+    _ExecutionContext.makeOp(name, nOutputs)
+}
+
+public enum Raw {
+
+static let generatedTensorFlowVersion = "1.14.1-dev20190421"
+static let generatedTensorFlowGitVersion = "v1.12.1-149-gd57b65578c"
+
+// @_frozen // SR-9739
+public enum A {
+    case apples
+    case oranges
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .apples: return "apples"
+            case .oranges: return "oranges"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum DataFormat {
+    case nchw
+    case nhwc
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .nchw: return "NCHW"
+            case .nhwc: return "NHWC"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum DataFormat1 {
+    case ncdhw
+    case ndhwc
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .ncdhw: return "NCDHW"
+            case .ndhwc: return "NDHWC"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum DataFormat4 {
+    case nchw
+    case nchwVectC
+    case nhwc
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .nchw: return "NCHW"
+            case .nchwVectC: return "NCHW_VECT_C"
+            case .nhwc: return "NHWC"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum DensityUnit {
+    case cm
+    case in_
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .cm: return "cm"
+            case .in_: return "in"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum Direction {
+    case bidirectional
+    case unidirectional
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .bidirectional: return "bidirectional"
+            case .unidirectional: return "unidirectional"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum Errors {
+    case ignore
+    case replace
+    case strict
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .ignore: return "ignore"
+            case .replace: return "replace"
+            case .strict: return "strict"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum FinalOp {
+    case div
+    case id
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .div: return "Div"
+            case .id: return "Id"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum Format {
+    case empty
+    case grayscale
+    case rgb
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .empty: return ""
+            case .grayscale: return "grayscale"
+            case .rgb: return "rgb"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum InputMode {
+    case autoSelect
+    case linearInput
+    case skipInput
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .autoSelect: return "auto_select"
+            case .linearInput: return "linear_input"
+            case .skipInput: return "skip_input"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum LossType {
+    case hingeLoss
+    case logisticLoss
+    case poissonLoss
+    case smoothHingeLoss
+    case squaredLoss
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .hingeLoss: return "hinge_loss"
+            case .logisticLoss: return "logistic_loss"
+            case .poissonLoss: return "poisson_loss"
+            case .smoothHingeLoss: return "smooth_hinge_loss"
+            case .squaredLoss: return "squared_loss"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum MergeOp {
+    case add
+    case max
+    case min
+    case mul
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .add: return "Add"
+            case .max: return "Max"
+            case .min: return "Min"
+            case .mul: return "Mul"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum Method {
+    case bilinear
+    case nearest
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .bilinear: return "bilinear"
+            case .nearest: return "nearest"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum Method3 {
+    case bilinear
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .bilinear: return "bilinear"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum Mode {
+    case minCombined
+    case minFirst
+    case scaled
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .minCombined: return "MIN_COMBINED"
+            case .minFirst: return "MIN_FIRST"
+            case .scaled: return "SCALED"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum Mode5 {
+    case reflect
+    case symmetric
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .reflect: return "REFLECT"
+            case .symmetric: return "SYMMETRIC"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum OutputEncoding {
+    case utf16Be
+    case utf32Be
+    case utf8
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .utf16Be: return "UTF-16-BE"
+            case .utf32Be: return "UTF-32-BE"
+            case .utf8: return "UTF-8"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum Padding {
+    case same
+    case valid
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .same: return "SAME"
+            case .valid: return "VALID"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum Padding2 {
+    case explicit
+    case same
+    case valid
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .explicit: return "EXPLICIT"
+            case .same: return "SAME"
+            case .valid: return "VALID"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum Reduction {
+    case max
+    case min
+    case prod
+    case sum
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .max: return "max"
+            case .min: return "min"
+            case .prod: return "prod"
+            case .sum: return "sum"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum RnnMode {
+    case gru
+    case lstm
+    case rnnRelu
+    case rnnTanh
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .gru: return "gru"
+            case .lstm: return "lstm"
+            case .rnnRelu: return "rnn_relu"
+            case .rnnTanh: return "rnn_tanh"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum RoundMode {
+    case halfToEven
+    case halfUp
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .halfToEven: return "HALF_TO_EVEN"
+            case .halfUp: return "HALF_UP"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum RoundMode6 {
+    case halfAwayFromZero
+    case halfToEven
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .halfAwayFromZero: return "HALF_AWAY_FROM_ZERO"
+            case .halfToEven: return "HALF_TO_EVEN"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum SplitType {
+    case inequality
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .inequality: return "inequality"
+            }
+        }
+    }
+}
+
+// @_frozen // SR-9739
+public enum Unit {
+    case byte
+    case utf8Char
+
+    @inlinable
+    var cName: String {
+        @inline(__always)
+        get {
+            switch self {
+            case .byte: return "BYTE"
+            case .utf8Char: return "UTF8_CHAR"
+            }
+        }
+    }
+}
+
+
+@inlinable @inline(__always)
+public static func a(
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("A", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+/// Raise a exception to abort the process when called.
+///
+/// If exit_without_error is true, the process will exit normally,
+/// otherwise it will exit with a SIGABORT signal.
+///
+/// Returns nothing but an exception.
+///
+/// - Attr error_msg: A string which is the message associated with the exception.
+@inlinable @inline(__always)
+public static func abort(
+    errorMsg: String,
+    exitWithoutError: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("Abort", nOutputs)
+    op.updateAttribute("error_msg", errorMsg)
+    op.updateAttribute("exit_without_error", exitWithoutError)
+    op.execute()
+}
+
+/// Computes the absolute value of a tensor.
+///
+/// Given a tensor `x`, this operation returns a tensor containing the absolute
+/// value of each element in `x`. For example, if x is an input element and y is
+/// an output element, this operation computes \\(y = |x|\\).
+@inlinable @inline(__always)
+public static func abs<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Abs", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns the element-wise sum of a list of tensors.
+///
+/// `tf.accumulate_n_v2` performs the same operation as `tf.add_n`, but does not
+/// wait for all of its inputs to be ready before beginning to sum. This can
+/// save memory if inputs are ready at different times, since minimum temporary
+/// storage is proportional to the output size rather than the inputs size.
+///
+/// Unlike the original `accumulate_n`, `accumulate_n_v2` is differentiable.
+///
+/// Returns a `Tensor` of same shape and type as the elements of `inputs`.
+///
+/// - Parameter inputs: A list of `Tensor` objects, each with same shape and type.
+///
+/// - Attr shape: Shape of elements of `inputs`.
+@inlinable @inline(__always)
+public static func accumulateNV2<T: Numeric & TensorFlowScalar>(
+    inputs: [Tensor<T>],
+    shape: TensorShape?
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("AccumulateNV2", nOutputs)
+    op.updateAttribute("N", inputs.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("shape", shape)
+    op.addInputList(inputs)
+    return op.execute(Int(1))
+}
+
+/// Computes acos of x element-wise.
+@inlinable @inline(__always)
+public static func acos<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Acos", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes inverse hyperbolic cosine of x element-wise.
+@inlinable @inline(__always)
+public static func acosh<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Acosh", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns x + y element-wise.
+///
+/// *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func add<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Add", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns x + y element-wise.
+///
+/// *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func add(
+    _ x: StringTensor,
+    _ y: StringTensor
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("Add", nOutputs)
+    op.updateAttribute("T", TensorDataType(TF_STRING))
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Add an `N`-minibatch `SparseTensor` to a `SparseTensorsMap`, return `N` handles.
+///
+/// A `SparseTensor` of rank `R` is represented by three tensors: `sparse_indices`,
+/// `sparse_values`, and `sparse_shape`, where
+///
+/// ```sparse_indices.shape[1] == sparse_shape.shape[0] == R```
+///
+/// An `N`-minibatch of `SparseTensor` objects is represented as a `SparseTensor`
+/// having a first `sparse_indices` column taking values between `[0, N)`, where
+/// the minibatch size `N == sparse_shape[0]`.
+///
+/// The input `SparseTensor` must have rank `R` greater than 1, and the first
+/// dimension is treated as the minibatch dimension.  Elements of the `SparseTensor`
+/// must be sorted in increasing order of this first dimension.  The stored
+/// `SparseTensor` objects pointed to by each row of the output `sparse_handles`
+/// will have rank `R-1`.
+///
+/// The `SparseTensor` values can then be read out as part of a minibatch by passing
+/// the given keys as vector elements to `TakeManySparseFromTensorsMap`.  To ensure
+/// the correct `SparseTensorsMap` is accessed, ensure that the same
+/// `container` and `shared_name` are passed to that Op.  If no `shared_name`
+/// is provided here, instead use the *name* of the Operation created by calling
+/// `AddManySparseToTensorsMap` as the `shared_name` passed to
+/// `TakeManySparseFromTensorsMap`.  Ensure the Operations are colocated.
+///
+/// - Parameters:
+///     - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
+///         `sparse_indices[:, 0]` must be ordered values in `[0, N)`.
+///     - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
+///     - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
+///         The minibatch size `N == sparse_shape[0]`.
+///
+/// - Attrs:
+///     - container: The container name for the `SparseTensorsMap` created by this op.
+///     - shared_name: The shared name for the `SparseTensorsMap` created by this op.
+///         If blank, the new Operation's unique name is used.
+///
+/// - Output sparse_handles: 1-D.  The handles of the `SparseTensor` now stored in the
+///     `SparseTensorsMap`.  Shape: `[N]`.
+@inlinable @inline(__always)
+public static func addManySparseToTensorsMap<T: TensorFlowScalar>(
+    sparseIndices: Tensor<Int64>,
+    sparseValues: Tensor<T>,
+    sparseShape: Tensor<Int64>,
+    container: String,
+    sharedName: String
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("AddManySparseToTensorsMap", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(sparseIndices)
+    op.addInput(sparseValues)
+    op.addInput(sparseShape)
+    return op.execute(Int(1))
+}
+
+/// Add all input tensors element wise.
+///
+/// - Parameter inputs: Must all be the same size and shape.
+@inlinable @inline(__always)
+public static func addN<T: Numeric & TensorFlowScalar>(
+    inputs: [Tensor<T>]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("AddN", nOutputs)
+    op.updateAttribute("N", inputs.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInputList(inputs)
+    return op.execute(Int(1))
+}
+
+/// Add a `SparseTensor` to a `SparseTensorsMap` return its handle.
+///
+/// A `SparseTensor` is represented by three tensors: `sparse_indices`,
+/// `sparse_values`, and `sparse_shape`.
+///
+/// This operator takes the given `SparseTensor` and adds it to a container
+/// object (a `SparseTensorsMap`).  A unique key within this container is generated
+/// in the form of an `int64`, and this is the value that is returned.
+///
+/// The `SparseTensor` can then be read out as part of a minibatch by passing
+/// the key as a vector element to `TakeManySparseFromTensorsMap`.  To ensure
+/// the correct `SparseTensorsMap` is accessed, ensure that the same
+/// `container` and `shared_name` are passed to that Op.  If no `shared_name`
+/// is provided here, instead use the *name* of the Operation created by calling
+/// `AddSparseToTensorsMap` as the `shared_name` passed to
+/// `TakeManySparseFromTensorsMap`.  Ensure the Operations are colocated.
+///
+/// - Parameters:
+///     - sparse_indices: 2-D.  The `indices` of the `SparseTensor`.
+///     - sparse_values: 1-D.  The `values` of the `SparseTensor`.
+///     - sparse_shape: 1-D.  The `shape` of the `SparseTensor`.
+///
+/// - Attrs:
+///     - container: The container name for the `SparseTensorsMap` created by this op.
+///     - shared_name: The shared name for the `SparseTensorsMap` created by this op.
+///         If blank, the new Operation's unique name is used.
+///
+/// - Output sparse_handle: 0-D.  The handle of the `SparseTensor` now stored in the
+///     `SparseTensorsMap`.
+@inlinable @inline(__always)
+public static func addSparseToTensorsMap<T: TensorFlowScalar>(
+    sparseIndices: Tensor<Int64>,
+    sparseValues: Tensor<T>,
+    sparseShape: Tensor<Int64>,
+    container: String,
+    sharedName: String
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("AddSparseToTensorsMap", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(sparseIndices)
+    op.addInput(sparseValues)
+    op.addInput(sparseShape)
+    return op.execute(Int(1))
+}
+
+/// Returns x + y element-wise.
+///
+/// *NOTE*: `Add` supports broadcasting. `AddN` does not. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func addV2<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("AddV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Deprecated. Disallowed in GraphDef version >= 2.
+@inlinable @inline(__always)
+public static func adjustContrast<T: Numeric & TensorFlowScalar>(
+    images: Tensor<T>,
+    contrastFactor: Tensor<Float>,
+    minValue: Tensor<Float>,
+    maxValue: Tensor<Float>
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("AdjustContrast", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(images)
+    op.addInput(contrastFactor)
+    op.addInput(minValue)
+    op.addInput(maxValue)
+    return op.execute(Int(1))
+}
+
+/// Adjust the contrast of one or more images.
+///
+/// `images` is a tensor of at least 3 dimensions.  The last 3 dimensions are
+/// interpreted as `[height, width, channels]`.  The other dimensions only
+/// represent a collection of images, such as `[batch, height, width, channels].`
+///
+/// Contrast is adjusted independently for each channel of each image.
+///
+/// For each channel, the Op first computes the mean of the image pixels in the
+/// channel and then adjusts each component of each pixel to
+/// `(x - mean) * contrast_factor + mean`.
+///
+/// - Parameters:
+///     - images: Images to adjust.  At least 3-D.
+///     - contrast_factor: A float multiplier for adjusting contrast.
+///
+/// - Output output: The contrast-adjusted image or images.
+@inlinable @inline(__always)
+public static func adjustContrastv2<T: FloatingPoint & TensorFlowScalar>(
+    images: Tensor<T>,
+    contrastFactor: Tensor<Float>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("AdjustContrastv2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(images)
+    op.addInput(contrastFactor)
+    return op.execute(Int(1))
+}
+
+/// Adjust the hue of one or more images.
+///
+/// `images` is a tensor of at least 3 dimensions.  The last dimension is
+/// interpretted as channels, and must be three.
+///
+/// The input image is considered in the RGB colorspace. Conceptually, the RGB
+/// colors are first mapped into HSV. A delta is then applied all the hue values,
+/// and then remapped back to RGB colorspace.
+///
+/// - Parameters:
+///     - images: Images to adjust.  At least 3-D.
+///     - delta: A float delta to add to the hue.
+///
+/// - Output output: The hue-adjusted image or images.
+@inlinable @inline(__always)
+public static func adjustHue<T: FloatingPoint & TensorFlowScalar>(
+    images: Tensor<T>,
+    delta: Tensor<Float>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("AdjustHue", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(images)
+    op.addInput(delta)
+    return op.execute(Int(1))
+}
+
+/// Adjust the saturation of one or more images.
+///
+/// `images` is a tensor of at least 3 dimensions.  The last dimension is
+/// interpretted as channels, and must be three.
+///
+/// The input image is considered in the RGB colorspace. Conceptually, the RGB
+/// colors are first mapped into HSV. A scale is then applied all the saturation
+/// values, and then remapped back to RGB colorspace.
+///
+/// - Parameters:
+///     - images: Images to adjust.  At least 3-D.
+///     - scale: A float scale to add to the saturation.
+///
+/// - Output output: The hue-adjusted image or images.
+@inlinable @inline(__always)
+public static func adjustSaturation<T: FloatingPoint & TensorFlowScalar>(
+    images: Tensor<T>,
+    scale: Tensor<Float>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("AdjustSaturation", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(images)
+    op.addInput(scale)
+    return op.execute(Int(1))
+}
+
+/// Computes the "logical and" of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///     - input: The tensor to reduce.
+///     - reduction_indices: The dimensions to reduce. Must be in the range
+///         `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func all<Tidx: BinaryInteger & TensorFlowScalar>(
+    _ input: Tensor<Bool>,
+    reductionIndices: Tensor<Tidx>,
+    keepDims: Bool = false
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("All", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(reductionIndices)
+    return op.execute(Int(1))
+}
+
+/// Generates labels for candidate sampling with a learned unigram distribution.
+///
+/// See explanations of candidate sampling and the data formats at
+/// go/candidate-sampling.
+///
+/// For each batch, this op picks a single set of sampled candidate labels.
+///
+/// The advantages of sampling candidates per-batch are simplicity and the
+/// possibility of efficient dense matrix multiplication. The disadvantage is that
+/// the sampled candidates must be chosen independently of the context and of the
+/// true labels.
+///
+/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
+///     IDs of the num_true target_classes in the corresponding original label.
+///
+/// - Attrs:
+///     - num_true: Number of true labels per context.
+///     - num_sampled: Number of candidates to produce.
+///     - unique: If unique is true, we sample with rejection, so that all sampled
+///         candidates in a batch are unique. This requires some approximation to
+///         estimate the post-rejection sampling probabilities.
+///     - seed: If either seed or seed2 are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///     - sampled_candidates: A vector of length num_sampled, in which each element is
+///         the ID of a sampled candidate.
+///     - true_expected_count: A batch_size * num_true matrix, representing
+///         the number of times each candidate is expected to occur in a batch
+///         of sampled candidates. If unique=true, then this is a probability.
+///     - sampled_expected_count: A vector of length num_sampled, for each sampled
+///         candidate representing the number of times the candidate is expected
+///         to occur in a batch of sampled candidates.  If unique=true, then this is a
+///         probability.
+@inlinable @inline(__always)
+public static func allCandidateSampler(
+    trueClasses: Tensor<Int64>,
+    numTrue: Int64,
+    numSampled: Int64,
+    unique: Bool,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("AllCandidateSampler", nOutputs)
+    op.updateAttribute("num_true", numTrue)
+    op.updateAttribute("num_sampled", numSampled)
+    op.updateAttribute("unique", unique)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(trueClasses)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// An Op to exchange data across TPU replicas.
+///
+/// On each replica, the input is split into `split_count` blocks along
+/// `split_dimension` and send to the other replicas given group_assignment. After
+/// receiving `split_count` - 1 blocks from other replicas, we concatenate the
+/// blocks along `concat_dimension` as the output.
+///
+/// For example, suppose there are 2 TPU replicas:
+/// replica 0 receives input: `[[A, B]]`
+/// replica 1 receives input: `[[C, D]]`
+///
+/// group_assignment=`[[0, 1]]`
+/// concat_dimension=0
+/// split_dimension=1
+/// split_count=2
+///
+/// replica 0's output: `[[A], [C]]`
+/// replica 1's output: `[[B], [D]]`
+///
+/// - Parameters:
+///     - input: The local input to the sum.
+///     - group_assignment: An int32 tensor with shape
+///         [num_groups, num_replicas_per_group]. `group_assignment[i]` represents the
+///         replica ids in the ith subgroup.
+///
+/// - Attrs:
+///     - T: The type of elements to be exchanged.
+///     - concat_dimension: The dimension number to concatenate.
+///     - split_dimension: The dimension number to split.
+///     - split_count: The number of splits, this number must equal to the sub-group
+///         size(group_assignment.get_shape()[1])
+///
+/// - Output output: The exchanged result.
+@inlinable @inline(__always)
+public static func allToAll<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    groupAssignment: Tensor<Int32>,
+    concatDimension: Int64,
+    splitDimension: Int64,
+    splitCount: Int64
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("AllToAll", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("concat_dimension", concatDimension)
+    op.updateAttribute("split_dimension", splitDimension)
+    op.updateAttribute("split_count", splitCount)
+    op.addInput(input)
+    op.addInput(groupAssignment)
+    return op.execute(Int(1))
+}
+
+/// Returns the argument of a complex number.
+///
+/// Given a tensor `input` of complex numbers, this operation returns a tensor of
+/// type `float` that is the argument of each element in `input`. All elements in
+/// `input` must be complex numbers of the form \\(a + bj\\), where *a*
+/// is the real part and *b* is the imaginary part.
+///
+/// The argument returned by this operation is of the form \\(atan2(b, a)\\).
+///
+/// For example:
+///
+/// ```
+/// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
+/// tf.angle(input) ==> [2.0132, 1.056]
+/// ```
+///
+/// @compatibility(numpy)
+/// Equivalent to np.angle.
+/// @end_compatibility
+@inlinable @inline(__always)
+public static func angle<
+    T: TensorFlowScalar,
+    Tout: FloatingPoint & TensorFlowScalar
+>(
+    _ input: Tensor<T>
+) -> Tensor<Tout> {
+  let nOutputs = Int(1)
+    let op = makeOp("Angle", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tout", Tout.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// A container for an iterator resource.
+///
+/// - Output handle: A handle to the iterator that can be passed to a "MakeIterator" or
+///     "IteratorGetNext" op. In contrast to Iterator, AnonymousIterator prevents
+///     resource sharing by name, and does not keep a reference to the resource
+///     container.
+@inlinable @inline(__always)
+public static func anonymousIterator(
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("AnonymousIterator", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    return op.execute(Int(1))
+}
+
+/// A container for an iterator resource.
+///
+/// - Outputs:
+///     - handle: A handle to the iterator that can be passed to a "MakeIterator" or
+///         "IteratorGetNext" op. In contrast to Iterator, AnonymousIterator prevents
+///         resource sharing by name, and does not keep a reference to the resource
+///         container.
+///     - deleter: A variant deleter that should be passed into the op that deletes the iterator.
+@inlinable @inline(__always)
+public static func anonymousIteratorV2(
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> (handle: ResourceHandle, deleter: VariantHandle) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("AnonymousIteratorV2", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Computes the "logical or" of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///     - input: The tensor to reduce.
+///     - reduction_indices: The dimensions to reduce. Must be in the range
+///         `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func any<Tidx: BinaryInteger & TensorFlowScalar>(
+    _ input: Tensor<Bool>,
+    reductionIndices: Tensor<Tidx>,
+    keepDims: Bool = false
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("Any", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(reductionIndices)
+    return op.execute(Int(1))
+}
+
+/// Returns the truth value of abs(x-y) < tolerance element-wise.
+@inlinable @inline(__always)
+public static func approximateEqual<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>,
+    tolerance: Double = 1e-05
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("ApproximateEqual", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("tolerance", tolerance)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns the index with the largest value across dimensions of a tensor.
+///
+/// Note that in case of ties the identity of the return value is not guaranteed.
+///
+/// Usage:
+///   ```python
+///   import tensorflow as tf
+///   a = [1, 10, 26.9, 2.8, 166.32, 62.3]
+///   b = tf.math.argmax(input = a)
+///   c = tf.keras.backend.eval(b)  
+///   # c = 4
+///   # here a[4] = 166.32 which is the largest element of a across axis 0
+///   ```
+///
+/// - Parameter dimension: int32 or int64, must be in the range `[-rank(input), rank(input))`.
+///     Describes which dimension of the input Tensor to reduce across. For vectors,
+///     use dimension = 0.
+@inlinable @inline(__always)
+public static func argMax<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar,
+    OutputType: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    dimension: Tensor<Tidx>
+) -> Tensor<OutputType> {
+  let nOutputs = Int(1)
+    let op = makeOp("ArgMax", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.updateAttribute("output_type", OutputType.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(dimension)
+    return op.execute(Int(1))
+}
+
+/// Returns the index with the smallest value across dimensions of a tensor.
+///
+/// Note that in case of ties the identity of the return value is not guaranteed.
+///
+/// Usage:
+///   ```python
+///   import tensorflow as tf
+///   a = [1, 10, 26.9, 2.8, 166.32, 62.3]
+///   b = tf.math.argmin(input = a)
+///   c = tf.keras.backend.eval(b)  
+///   # c = 0
+///   # here a[0] = 1 which is the smallest element of a across axis 0
+///   ```
+///
+/// - Parameter dimension: int32 or int64, must be in the range `[-rank(input), rank(input))`.
+///     Describes which dimension of the input Tensor to reduce across. For vectors,
+///     use dimension = 0.
+@inlinable @inline(__always)
+public static func argMin<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar,
+    OutputType: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    dimension: Tensor<Tidx>
+) -> Tensor<OutputType> {
+  let nOutputs = Int(1)
+    let op = makeOp("ArgMin", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.updateAttribute("output_type", OutputType.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(dimension)
+    return op.execute(Int(1))
+}
+
+/// Converts each entry in the given tensor to strings.  Supports many numeric
+///
+/// types and boolean.
+///
+/// - Attrs:
+///     - precision: The post-decimal precision to use for floating point numbers.
+///         Only used if precision > -1.
+///     - scientific: Use scientific notation for floating point numbers.
+///     - shortest: Use shortest representation (either scientific or standard) for
+///         floating point numbers.
+///     - width: Pad pre-decimal numbers to this width.
+///         Applies to both floating point and integer numbers.
+///         Only used if width > -1.
+///     - fill: The value to pad if width > -1.  If empty, pads with spaces.
+///         Another typical value is '0'.  String cannot be longer than 1 character.
+@inlinable @inline(__always)
+public static func asString<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    precision: Int64 = -1,
+    scientific: Bool = false,
+    shortest: Bool = false,
+    width: Int64 = -1,
+    fill: String
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("AsString", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("precision", precision)
+    op.updateAttribute("scientific", scientific)
+    op.updateAttribute("shortest", shortest)
+    op.updateAttribute("width", width)
+    op.updateAttribute("fill", fill)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Computes the trignometric inverse sine of x element-wise.
+///
+/// The `tf.math.asin` operation returns the inverse of `tf.math.sin`, such that
+/// if `y = tf.math.sin(x)` then, `x = tf.math.asin(y)`.
+///
+/// **Note**: The output of `tf.math.asin` will lie within the invertible range 
+/// of sine, i.e [-pi/2, pi/2].
+///
+/// For example:
+///
+/// ```python
+/// # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)]
+/// x = tf.constant([1.047, 0.785])
+/// y = tf.math.sin(x) # [0.8659266, 0.7068252]
+///
+/// tf.math.asin(y) # [1.047, 0.785] = x
+/// ```
+///
+@inlinable @inline(__always)
+public static func asin<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Asin", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes inverse hyperbolic sine of x element-wise.
+@inlinable @inline(__always)
+public static func asinh<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Asinh", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Asserts that the given condition is true.
+///
+/// If `condition` evaluates to false, print the list of tensors in `data`.
+/// `summarize` determines how many entries of the tensors to print.
+///
+/// - Parameters:
+///     - condition: The condition to evaluate.
+///     - data: The tensors to print out when condition is false.
+///
+/// - Attr summarize: Print this many entries of each tensor.
+@inlinable @inline(__always)
+public static func assert<T: TensorArrayProtocol>(
+    condition: Tensor<Bool>,
+    data: T,
+    summarize: Int64 = 3
+) {
+  let nOutputs = 0
+    let op = makeOp("Assert", nOutputs)
+    op.updateAttribute("T", data._typeList)
+    op.updateAttribute("summarize", summarize)
+    op.addInput(condition)
+    op.addInputList(data)
+    op.execute()
+}
+
+/// Adds a value to the current value of a variable.
+///
+/// Any ReadVariableOp with a control dependency on this op is guaranteed to
+/// see the incremented value or a subsequent newer one.
+///
+/// - Parameters:
+///     - resource: handle to the resource in which to store the variable.
+///     - value: the value by which the variable will be incremented.
+///
+/// - Attr dtype: the dtype of the value.
+@inlinable @inline(__always)
+public static func assignAddVariableOp<Dtype: TensorFlowScalar>(
+    resource: ResourceHandle,
+    value: Tensor<Dtype>
+) {
+  let nOutputs = 0
+    let op = makeOp("AssignAddVariableOp", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(value)
+    op.execute()
+}
+
+/// Subtracts a value from the current value of a variable.
+///
+/// Any ReadVariableOp with a control dependency on this op is guaranteed to
+/// see the decremented value or a subsequent newer one.
+///
+/// - Parameters:
+///     - resource: handle to the resource in which to store the variable.
+///     - value: the value by which the variable will be incremented.
+///
+/// - Attr dtype: the dtype of the value.
+@inlinable @inline(__always)
+public static func assignSubVariableOp<Dtype: TensorFlowScalar>(
+    resource: ResourceHandle,
+    value: Tensor<Dtype>
+) {
+  let nOutputs = 0
+    let op = makeOp("AssignSubVariableOp", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(value)
+    op.execute()
+}
+
+/// Assigns a new value to a variable.
+///
+/// Any ReadVariableOp with a control dependency on this op is guaranteed to return
+/// this value or a subsequent newer value of the variable.
+///
+/// - Parameters:
+///     - resource: handle to the resource in which to store the variable.
+///     - value: the value to set the new tensor to use.
+///
+/// - Attr dtype: the dtype of the value.
+@inlinable @inline(__always)
+public static func assignVariableOp<Dtype: TensorFlowScalar>(
+    resource: ResourceHandle,
+    value: Tensor<Dtype>
+) {
+  let nOutputs = 0
+    let op = makeOp("AssignVariableOp", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(value)
+    op.execute()
+}
+
+/// Computes the trignometric inverse tangent of x element-wise.
+///
+/// The `tf.math.atan` operation returns the inverse of `tf.math.tan`, such that
+/// if `y = tf.math.tan(x)` then, `x = tf.math.atan(y)`.
+///
+/// **Note**: The output of `tf.math.atan` will lie within the invertible range 
+/// of tan, i.e (-pi/2, pi/2).
+///
+/// For example:
+///
+/// ```python
+/// # Note: [1.047, 0.785] ~= [(pi/3), (pi/4)]
+/// x = tf.constant([1.047, 0.785])
+/// y = tf.math.tan(x) # [1.731261, 0.99920404]
+///
+/// tf.math.atan(y) # [1.047, 0.785] = x
+/// ```
+///
+@inlinable @inline(__always)
+public static func atan<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Atan", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes arctangent of `y/x` element-wise, respecting signs of the arguments.
+///
+/// This is the angle \( \theta \in [-\pi, \pi] \) such that
+/// \[ x = r \cos(\theta) \]
+/// and
+/// \[ y = r \sin(\theta) \]
+/// where \(r = \sqrt(x^2 + y^2) \).
+@inlinable @inline(__always)
+public static func atan2<T: FloatingPoint & TensorFlowScalar>(
+    _ y: Tensor<T>,
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Atan2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(y)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes inverse hyperbolic tangent of x element-wise.
+@inlinable @inline(__always)
+public static func atanh<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Atanh", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func attr(
+    _ a: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("Attr", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrBool(
+    _ a: Bool
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrBool", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrBoolList(
+    _ a: [Bool]
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrBoolList", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrDefault(
+    _ a: String = "banana"
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrDefault", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrEmptyListDefault(
+    _ a: [Double]
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrEmptyListDefault", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrEnum(
+    _ a: A
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrEnum", nOutputs)
+    op.updateAttribute("a", a.cName)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrEnumList(
+    _ a: [String]
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrEnumList", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrFloat(
+    _ a: Double
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrFloat", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrListDefault(
+    _ a: [Int32] = [5, 15]
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrListDefault", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrListMin(
+    _ a: [Int32]
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrListMin", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrListTypeDefault<T: TensorFlowScalar>(
+    _ a: [Tensor<T>],
+    _ b: [Tensor<T>]
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrListTypeDefault", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("N", a.count)
+    op.addInputList(a)
+    op.addInputList(b)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrMin(
+    _ a: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrMin", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrPartialShape(
+    _ a: TensorShape?
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrPartialShape", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrPartialShapeList(
+    _ a: [TensorShape?]
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrPartialShapeList", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrShape(
+    _ a: TensorShape?
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrShape", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrShapeList(
+    _ a: [TensorShape?]
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrShapeList", nOutputs)
+    op.updateAttribute("a", a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func attrTypeDefault<T: TensorFlowScalar>(
+    _ a: Tensor<T>
+) {
+  let nOutputs = 0
+    let op = makeOp("AttrTypeDefault", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    op.execute()
+}
+
+/// Produces a visualization of audio data over time.
+///
+/// Spectrograms are a standard way of representing audio information as a series of
+/// slices of frequency information, one slice for each window of time. By joining
+/// these together into a sequence, they form a distinctive fingerprint of the sound
+/// over time.
+///
+/// This op expects to receive audio data as an input, stored as floats in the range
+/// -1 to 1, together with a window width in samples, and a stride specifying how
+/// far to move the window between slices. From this it generates a three
+/// dimensional output. The lowest dimension has an amplitude value for each
+/// frequency during that time slice. The next dimension is time, with successive
+/// frequency slices. The final dimension is for the channels in the input, so a
+/// stereo audio input would have two here for example.
+///
+/// This means the layout when converted and saved as an image is rotated 90 degrees
+/// clockwise from a typical spectrogram. Time is descending down the Y axis, and
+/// the frequency decreases from left to right.
+///
+/// Each value in the result represents the square root of the sum of the real and
+/// imaginary parts of an FFT on the current window of samples. In this way, the
+/// lowest dimension represents the power of each frequency in the current window,
+/// and adjacent windows are concatenated in the next dimension.
+///
+/// To get a more intuitive and visual look at what this operation does, you can run
+/// tensorflow/examples/wav_to_spectrogram to read in an audio file and save out the
+/// resulting spectrogram as a PNG image.
+///
+/// - Parameter input: Float representation of audio data.
+///
+/// - Attrs:
+///     - window_size: How wide the input window is in samples. For the highest efficiency
+///         this should be a power of two, but other values are accepted.
+///     - stride: How widely apart the center of adjacent sample windows should be.
+///     - magnitude_squared: Whether to return the squared magnitude or just the
+///         magnitude. Using squared magnitude can avoid extra calculations.
+///
+/// - Output spectrogram: 3D representation of the audio frequencies as an image.
+@inlinable @inline(__always)
+public static func audioSpectrogram(
+    _ input: Tensor<Float>,
+    windowSize: Int64,
+    stride: Int64,
+    magnitudeSquared: Bool = false
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("AudioSpectrogram", nOutputs)
+    op.updateAttribute("window_size", windowSize)
+    op.updateAttribute("stride", stride)
+    op.updateAttribute("magnitude_squared", magnitudeSquared)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Outputs a `Summary` protocol buffer with audio.
+///
+/// The summary has up to `max_outputs` summary values containing audio. The
+/// audio is built from `tensor` which must be 3-D with shape `[batch_size,
+/// frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are
+/// assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`.
+///
+/// The `tag` argument is a scalar `Tensor` of type `string`.  It is used to
+/// build the `tag` of the summary values:
+///
+/// *  If `max_outputs` is 1, the summary value tag is '*tag*/audio'.
+/// *  If `max_outputs` is greater than 1, the summary value tags are
+///    generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc.
+///
+/// - Parameters:
+///     - tag: Scalar. Used to build the `tag` attribute of the summary values.
+///     - tensor: 2-D of shape `[batch_size, frames]`.
+///
+/// - Attrs:
+///     - sample_rate: The sample rate of the signal in hertz.
+///     - max_outputs: Max number of batch elements to generate audio for.
+///
+/// - Output summary: Scalar. Serialized `Summary` protocol buffer.
+@inlinable @inline(__always)
+public static func audioSummary(
+    tag: StringTensor,
+    _ tensor: Tensor<Float>,
+    sampleRate: Double,
+    maxOutputs: Int64 = 3
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("AudioSummary", nOutputs)
+    op.updateAttribute("sample_rate", sampleRate)
+    op.updateAttribute("max_outputs", maxOutputs)
+    op.addInput(tag)
+    op.addInput(tensor)
+    return op.execute(Int(1))
+}
+
+/// Outputs a `Summary` protocol buffer with audio.
+///
+/// The summary has up to `max_outputs` summary values containing audio. The
+/// audio is built from `tensor` which must be 3-D with shape `[batch_size,
+/// frames, channels]` or 2-D with shape `[batch_size, frames]`. The values are
+/// assumed to be in the range of `[-1.0, 1.0]` with a sample rate of `sample_rate`.
+///
+/// The `tag` argument is a scalar `Tensor` of type `string`.  It is used to
+/// build the `tag` of the summary values:
+///
+/// *  If `max_outputs` is 1, the summary value tag is '*tag*/audio'.
+/// *  If `max_outputs` is greater than 1, the summary value tags are
+///    generated sequentially as '*tag*/audio/0', '*tag*/audio/1', etc.
+///
+/// - Parameters:
+///     - tag: Scalar. Used to build the `tag` attribute of the summary values.
+///     - tensor: 2-D of shape `[batch_size, frames]`.
+///     - sample_rate: The sample rate of the signal in hertz.
+///
+/// - Attr max_outputs: Max number of batch elements to generate audio for.
+///
+/// - Output summary: Scalar. Serialized `Summary` protocol buffer.
+@inlinable @inline(__always)
+public static func audioSummaryV2(
+    tag: StringTensor,
+    _ tensor: Tensor<Float>,
+    sampleRate: Tensor<Float>,
+    maxOutputs: Int64 = 3
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("AudioSummaryV2", nOutputs)
+    op.updateAttribute("max_outputs", maxOutputs)
+    op.addInput(tag)
+    op.addInput(tensor)
+    op.addInput(sampleRate)
+    return op.execute(Int(1))
+}
+
+/// Performs average pooling on the input.
+///
+/// Each entry in `output` is the mean of the corresponding size `ksize`
+/// window in `value`.
+///
+/// - Parameter value: 4-D with shape `[batch, height, width, channels]`.
+///
+/// - Attrs:
+///     - ksize: The size of the sliding window for each dimension of `value`.
+///     - strides: The stride of the sliding window for each dimension of `value`.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, in_channels, in_height, in_width].
+///
+/// - Output output: The average pooled output tensor.
+@inlinable @inline(__always)
+public static func avgPool<T: FloatingPoint & TensorFlowScalar>(
+    value: Tensor<T>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("AvgPool", nOutputs)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(value)
+    return op.execute(Int(1))
+}
+
+/// Performs 3D average pooling on the input.
+///
+/// - Parameter input: Shape `[batch, depth, rows, cols, channels]` tensor to pool over.
+///
+/// - Attrs:
+///     - ksize: 1-D tensor of length 5. The size of the window for each dimension of
+///         the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+///     - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///         dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: The data format of the input and output data. With the
+///         default format "NDHWC", the data is stored in the order of:
+///             [batch, in_depth, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCDHW", the data storage order is:
+///             [batch, in_channels, in_depth, in_height, in_width].
+///
+/// - Output output: The average pooled output tensor.
+@inlinable @inline(__always)
+public static func avgPool3D<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat1 = .ndhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("AvgPool3D", nOutputs)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Computes gradients of average pooling function.
+///
+/// - Parameters:
+///     - orig_input_shape: The original input dimensions.
+///     - grad: Output backprop of shape `[batch, depth, rows, cols, channels]`.
+///
+/// - Attrs:
+///     - ksize: 1-D tensor of length 5. The size of the window for each dimension of
+///         the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+///     - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///         dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: The data format of the input and output data. With the
+///         default format "NDHWC", the data is stored in the order of:
+///             [batch, in_depth, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCDHW", the data storage order is:
+///             [batch, in_channels, in_depth, in_height, in_width].
+///
+/// - Output output: The backprop for input.
+@inlinable @inline(__always)
+public static func avgPool3DGrad<T: FloatingPoint & TensorFlowScalar>(
+    origInputShape: Tensor<Int32>,
+    grad: Tensor<T>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat1 = .ndhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("AvgPool3DGrad", nOutputs)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(origInputShape)
+    op.addInput(grad)
+    return op.execute(Int(1))
+}
+
+/// Computes gradients of the average pooling function.
+///
+/// - Parameters:
+///     - orig_input_shape: 1-D.  Shape of the original input to `avg_pool`.
+///     - grad: 4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t.
+///         the output of `avg_pool`.
+///
+/// - Attrs:
+///     - ksize: The size of the sliding window for each dimension of the input.
+///     - strides: The stride of the sliding window for each dimension of the input.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, in_channels, in_height, in_width].
+///
+/// - Output output: 4-D.  Gradients w.r.t. the input of `avg_pool`.
+@inlinable @inline(__always)
+public static func avgPoolGrad<T: FloatingPoint & TensorFlowScalar>(
+    origInputShape: Tensor<Int32>,
+    grad: Tensor<T>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("AvgPoolGrad", nOutputs)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(origInputShape)
+    op.addInput(grad)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func b(
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("B", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+/// Batches all input tensors nondeterministically.
+///
+/// When many instances of this Op are being run concurrently with the same
+/// container/shared_name in the same device, some will output zero-shaped Tensors
+/// and others will output Tensors of size up to max_batch_size.
+///
+/// All Tensors in in_tensors are batched together (so, for example, labels and
+/// features should be batched with a single instance of this operation.
+///
+/// Each invocation of batch emits an `id` scalar which will be used to identify
+/// this particular invocation when doing unbatch or its gradient.
+///
+/// Each op which emits a non-empty batch will also emit a non-empty batch_index
+/// Tensor, which, is a [K, 3] matrix where each row contains the invocation's id,
+/// start, and length of elements of each set of Tensors present in batched_tensors.
+///
+/// Batched tensors are concatenated along the first dimension, and all tensors in
+/// in_tensors must have the first dimension of the same size.
+///
+/// in_tensors: The tensors to be batched.
+/// num_batch_threads: Number of scheduling threads for processing batches of work.
+///  Determines the number of batches processed in parallel.
+/// max_batch_size: Batch sizes will never be bigger than this.
+/// batch_timeout_micros: Maximum number of microseconds to wait before outputting
+///  an incomplete batch.
+/// allowed_batch_sizes: Optional list of allowed batch sizes. If left empty, does
+///  nothing. Otherwise, supplies a list of batch sizes, causing the op to pad
+///  batches up to one of those sizes. The entries must increase monotonically, and
+///  the final entry must equal max_batch_size.
+/// grad_timeout_micros: The timeout to use for the gradient. See Unbatch.
+/// batched_tensors: Either empty tensors or a batch of concatenated Tensors.
+/// batch_index: If out_tensors is non-empty, has information to invert it.
+/// container: Controls the scope of sharing of this batch.
+/// id: always contains a scalar with a unique ID for this invocation of Batch.
+/// shared_name: Concurrently running instances of batch in the same device with the
+///  same container and shared_name will batch their elements together. If left
+///  empty, the op name will be used as the shared name.
+/// T: the types of tensors to be batched.
+@inlinable @inline(__always)
+public static func batch<T: TensorArrayProtocol>(
+    inTensors: T,
+    numBatchThreads: Int64,
+    maxBatchSize: Int64,
+    maxEnqueuedBatches: Int64 = 10,
+    batchTimeoutMicros: Int64,
+    allowedBatchSizes: [Int32],
+    gradTimeoutMicros: Int64,
+    container: String,
+    sharedName: String,
+    batchingQueue: String
+) -> (batchedTensors: T, batchIndex: Tensor<Int64>, id: Tensor<Int64>) {
+  let nOutputs = Int(inTensors._typeList.count) + Int(1) + Int(1)
+    let op = makeOp("Batch", nOutputs)
+    op.updateAttribute("num_batch_threads", numBatchThreads)
+    op.updateAttribute("max_batch_size", maxBatchSize)
+    op.updateAttribute("max_enqueued_batches", maxEnqueuedBatches)
+    op.updateAttribute("batch_timeout_micros", batchTimeoutMicros)
+    op.updateAttribute("allowed_batch_sizes", allowedBatchSizes)
+    op.updateAttribute("grad_timeout_micros", gradTimeoutMicros)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("batching_queue", batchingQueue)
+    op.updateAttribute("T", inTensors._typeList)
+    op.addInputList(inTensors)
+    return op.execute(Int(inTensors._typeList.count), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchCholesky<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchCholesky", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchCholeskyGrad<T: FloatingPoint & TensorFlowScalar>(
+    l: Tensor<T>,
+    grad: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchCholeskyGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(l)
+    op.addInput(grad)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that batches `batch_size` elements from `input_dataset`.
+///
+/// - Parameter batch_size: A scalar representing the number of elements to accumulate in a
+///     batch.
+@inlinable @inline(__always)
+public static func batchDataset(
+    inputDataset: VariantHandle,
+    batchSize: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(batchSize)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that batches `batch_size` elements from `input_dataset`.
+///
+/// - Parameters:
+///     - batch_size: A scalar representing the number of elements to accumulate in a batch.
+///     - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
+///         is smaller than desired.
+@inlinable @inline(__always)
+public static func batchDatasetV2(
+    inputDataset: VariantHandle,
+    batchSize: Tensor<Int64>,
+    dropRemainder: Tensor<Bool>,
+    parallelCopy: Bool = false,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchDatasetV2", nOutputs)
+    op.updateAttribute("parallel_copy", parallelCopy)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(batchSize)
+    op.addInput(dropRemainder)
+    return op.execute(Int(1))
+}
+
+/// Batches all the inputs tensors to the computation done by the function.
+///
+/// So, for example, in the following code
+///
+///   ```python
+///
+///   # This input will be captured.
+///   y = tf.placeholder_with_default(1.0, shape=[])
+///
+///   @tf.Defun(tf.float32)
+///   def computation(a):
+///     return tf.matmul(a, a) + y
+///
+///   b = gen_batch_ops.batch_function(
+///           f=computation
+///           in_tensors=[a],
+///           captured_tensors=computation.captured_inputs,
+///           Tout=[o.type for o in computation.definition.signature.output_arg],
+///           num_batch_threads=1,
+///           max_batch_size=10,
+///           batch_timeout_micros=100000,  # 100ms
+///           allowed_batch_sizes=[3, 10],
+///           batching_queue="")
+///
+/// If more than one session.run call is simultaneously trying to compute `b`
+/// the values of `a` will be gathered, non-deterministically concatenated
+/// along the first axis, and only one thread will run the computation.
+///
+/// Assumes that all arguments of the function are Tensors which will be batched
+/// along their first dimension.
+///
+/// Arguments that are captured, are not batched. The session.run call which does
+/// the concatenation, will use the values of the captured tensors available to it.
+/// Therefore, typical uses of captured tensors should involve values which remain
+/// unchanged across session.run calls. Inference is a good example of this.
+///
+/// SparseTensor is not supported. The return value of the decorated function
+/// must be a Tensor or a list/tuple of Tensors.
+///
+/// - Parameters:
+///     - in_tensors: The tensors to be batched.
+///     - captured_tensors: The tensors which are captured in the function, and don't need
+///         to be batched.
+///
+/// - Attrs:
+///     - num_batch_threads: Number of scheduling threads for processing batches of work.
+///         Determines the number of batches processed in parallel.
+///     - max_batch_size: Batch sizes will never be bigger than this.
+///     - batch_timeout_micros: Maximum number of microseconds to wait before outputting
+///         an incomplete batch.
+///     - max_enqueued_batches: Maximum number of batches enqueued. Default: 10.
+///     - allowed_batch_sizes: Optional list of allowed batch sizes. If left empty, does
+///         nothing. Otherwise, supplies a list of batch sizes, causing the op to pad
+///         batches up to one of those sizes. The entries must increase monotonically, and
+///         the final entry must equal max_batch_size.
+///     - container: Controls the scope of sharing of this batch.
+///     - shared_name: Concurrently running instances of batch in the same device with the
+///         same container and shared_name will batch their elements together. If left
+///         empty, the op name will be used as the shared name.
+///     - Tin: the types of tensors to be batched.
+///     - Tcaptured: the types of the captured tensors.
+///     - Tout: the types of the output tensors.
+///
+/// - Output out_tensors: The output tensors.
+@inlinable @inline(__always)
+public static func batchFunction<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Tin: TensorArrayProtocol,
+    Tcaptured: TensorArrayProtocol,
+    Tout: TensorGroup
+>(
+    inTensors: Tin,
+    capturedTensors: Tcaptured,
+    f: (FIn) -> FOut,
+    numBatchThreads: Int64,
+    maxBatchSize: Int64,
+    batchTimeoutMicros: Int64,
+    maxEnqueuedBatches: Int64 = 10,
+    allowedBatchSizes: [Int32],
+    container: String,
+    sharedName: String,
+    batchingQueue: String
+) -> Tout {
+  let nOutputs = Int(Tout._typeList.count)
+    let op = makeOp("BatchFunction", nOutputs)
+    op.updateAttribute("f", f)
+    op.updateAttribute("num_batch_threads", numBatchThreads)
+    op.updateAttribute("max_batch_size", maxBatchSize)
+    op.updateAttribute("batch_timeout_micros", batchTimeoutMicros)
+    op.updateAttribute("max_enqueued_batches", maxEnqueuedBatches)
+    op.updateAttribute("allowed_batch_sizes", allowedBatchSizes)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("batching_queue", batchingQueue)
+    op.updateAttribute("Tin", inTensors._typeList)
+    op.updateAttribute("Tcaptured", capturedTensors._typeList)
+    op.updateAttribute("Tout", Tout._typeList)
+    op.addInputList(inTensors)
+    op.addInputList(capturedTensors)
+    return op.execute(Int(Tout._typeList.count))
+}
+
+/// Multiplies slices of two tensors in batches.
+///
+/// Multiplies all slices of `Tensor` `x` and `y` (each slice can be
+/// viewed as an element of a batch), and arranges the individual results
+/// in a single output tensor of the same batch size. Each of the
+/// individual slices can optionally be adjointed (to adjoint a matrix
+/// means to transpose and conjugate it) before multiplication by setting
+/// the `adj_x` or `adj_y` flag to `True`, which are by default `False`.
+///
+/// The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]`
+/// and `[..., r_y, c_y]`.
+///
+/// The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where:
+///
+///     r_o = c_x if adj_x else r_x
+///     c_o = r_y if adj_y else c_y
+///
+/// It is computed as:
+///
+///     output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])
+///
+/// - Parameters:
+///     - x: 2-D or higher with shape `[..., r_x, c_x]`.
+///     - y: 2-D or higher with shape `[..., r_y, c_y]`.
+///
+/// - Attrs:
+///     - adj_x: If `True`, adjoint the slices of `x`. Defaults to `False`.
+///     - adj_y: If `True`, adjoint the slices of `y`. Defaults to `False`.
+///
+/// - Output output: 3-D or higher with shape `[..., r_o, c_o]`
+@inlinable @inline(__always)
+public static func batchMatMul<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>,
+    adjX: Bool = false,
+    adjY: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchMatMul", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("adj_x", adjX)
+    op.updateAttribute("adj_y", adjY)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Multiplies slices of two tensors in batches.
+///
+/// Multiplies all slices of `Tensor` `x` and `y` (each slice can be
+/// viewed as an element of a batch), and arranges the individual results
+/// in a single output tensor of the same batch size. Each of the
+/// individual slices can optionally be adjointed (to adjoint a matrix
+/// means to transpose and conjugate it) before multiplication by setting
+/// the `adj_x` or `adj_y` flag to `True`, which are by default `False`.
+///
+/// The input tensors `x` and `y` are 2-D or higher with shape `[..., r_x, c_x]`
+/// and `[..., r_y, c_y]`.
+///
+/// The output tensor is 2-D or higher with shape `[..., r_o, c_o]`, where:
+///
+///     r_o = c_x if adj_x else r_x
+///     c_o = r_y if adj_y else c_y
+///
+/// It is computed as:
+///
+///     output[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])
+///
+/// *NOTE*: `BatchMatMulV2` supports broadcasting in the batch dimensions. More
+/// about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html).
+///
+///
+/// - Parameters:
+///     - x: 2-D or higher with shape `[..., r_x, c_x]`.
+///     - y: 2-D or higher with shape `[..., r_y, c_y]`.
+///
+/// - Attrs:
+///     - adj_x: If `True`, adjoint the slices of `x`. Defaults to `False`.
+///     - adj_y: If `True`, adjoint the slices of `y`. Defaults to `False`.
+///
+/// - Output output: 3-D or higher with shape `[..., r_o, c_o]`
+@inlinable @inline(__always)
+public static func batchMatMulV2<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>,
+    adjX: Bool = false,
+    adjY: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchMatMulV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("adj_x", adjX)
+    op.updateAttribute("adj_y", adjY)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixBandPart<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    numLower: Tensor<Int64>,
+    numUpper: Tensor<Int64>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchMatrixBandPart", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(numLower)
+    op.addInput(numUpper)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchMatrixDeterminant", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixDiag<T: TensorFlowScalar>(
+    diagonal: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchMatrixDiag", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(diagonal)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixDiagPart<T: TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchMatrixDiagPart", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixInverse<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    adjoint: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchMatrixInverse", nOutputs)
+    op.updateAttribute("adjoint", adjoint)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixSetDiag<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    diagonal: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchMatrixSetDiag", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(diagonal)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixSolve<T: FloatingPoint & TensorFlowScalar>(
+    matrix: Tensor<T>,
+    rhs: Tensor<T>,
+    adjoint: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchMatrixSolve", nOutputs)
+    op.updateAttribute("adjoint", adjoint)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(matrix)
+    op.addInput(rhs)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixSolveLs<T: FloatingPoint & TensorFlowScalar>(
+    matrix: Tensor<T>,
+    rhs: Tensor<T>,
+    l2Regularizer: Tensor<Double>,
+    fast: Bool = true
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchMatrixSolveLs", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("fast", fast)
+    op.addInput(matrix)
+    op.addInput(rhs)
+    op.addInput(l2Regularizer)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchMatrixTriangularSolve<T: FloatingPoint & TensorFlowScalar>(
+    matrix: Tensor<T>,
+    rhs: Tensor<T>,
+    lower: Bool = true,
+    adjoint: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchMatrixTriangularSolve", nOutputs)
+    op.updateAttribute("lower", lower)
+    op.updateAttribute("adjoint", adjoint)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(matrix)
+    op.addInput(rhs)
+    return op.execute(Int(1))
+}
+
+/// Batch normalization.
+///
+/// This op is deprecated. Prefer `tf.nn.batch_normalization`.
+///
+/// - Parameters:
+///     - t: A 4D input Tensor.
+///     - m: A 1D mean Tensor with size matching the last dimension of t.
+///         This is the first output from tf.nn.moments,
+///         or a saved moving average thereof.
+///     - v: A 1D variance Tensor with size matching the last dimension of t.
+///         This is the second output from tf.nn.moments,
+///         or a saved moving average thereof.
+///     - beta: A 1D beta Tensor with size matching the last dimension of t.
+///         An offset to be added to the normalized tensor.
+///     - gamma: A 1D gamma Tensor with size matching the last dimension of t.
+///         If "scale_after_normalization" is true, this tensor will be multiplied
+///         with the normalized tensor.
+///
+/// - Attrs:
+///     - variance_epsilon: A small float number to avoid dividing by 0.
+///     - scale_after_normalization: A bool indicating whether the resulted tensor
+///         needs to be multiplied with gamma.
+@inlinable @inline(__always)
+public static func batchNormWithGlobalNormalization<T: Numeric & TensorFlowScalar>(
+    t: Tensor<T>,
+    m: Tensor<T>,
+    v: Tensor<T>,
+    beta: Tensor<T>,
+    gamma: Tensor<T>,
+    varianceEpsilon: Double,
+    scaleAfterNormalization: Bool
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchNormWithGlobalNormalization", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("variance_epsilon", varianceEpsilon)
+    op.updateAttribute("scale_after_normalization", scaleAfterNormalization)
+    op.addInput(t)
+    op.addInput(m)
+    op.addInput(v)
+    op.addInput(beta)
+    op.addInput(gamma)
+    return op.execute(Int(1))
+}
+
+/// Gradients for batch normalization.
+///
+/// This op is deprecated. See `tf.nn.batch_normalization`.
+///
+/// - Parameters:
+///     - t: A 4D input Tensor.
+///     - m: A 1D mean Tensor with size matching the last dimension of t.
+///         This is the first output from tf.nn.moments,
+///         or a saved moving average thereof.
+///     - v: A 1D variance Tensor with size matching the last dimension of t.
+///         This is the second output from tf.nn.moments,
+///         or a saved moving average thereof.
+///     - gamma: A 1D gamma Tensor with size matching the last dimension of t.
+///         If "scale_after_normalization" is true, this Tensor will be multiplied
+///         with the normalized Tensor.
+///     - backprop: 4D backprop Tensor.
+///
+/// - Attrs:
+///     - variance_epsilon: A small float number to avoid dividing by 0.
+///     - scale_after_normalization: A bool indicating whether the resulted tensor
+///         needs to be multiplied with gamma.
+///
+/// - Outputs:
+///     - dx: 4D backprop tensor for input.
+///     - dm: 1D backprop tensor for mean.
+///     - dv: 1D backprop tensor for variance.
+///     - db: 1D backprop tensor for beta.
+///     - dg: 1D backprop tensor for gamma.
+@inlinable @inline(__always)
+public static func batchNormWithGlobalNormalizationGrad<T: Numeric & TensorFlowScalar>(
+    t: Tensor<T>,
+    m: Tensor<T>,
+    v: Tensor<T>,
+    gamma: Tensor<T>,
+    backprop: Tensor<T>,
+    varianceEpsilon: Double,
+    scaleAfterNormalization: Bool
+) -> (dx: Tensor<T>, dm: Tensor<T>, dv: Tensor<T>, db: Tensor<T>, dg: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("BatchNormWithGlobalNormalizationGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("variance_epsilon", varianceEpsilon)
+    op.updateAttribute("scale_after_normalization", scaleAfterNormalization)
+    op.addInput(t)
+    op.addInput(m)
+    op.addInput(v)
+    op.addInput(gamma)
+    op.addInput(backprop)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchSelfAdjointEig<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchSelfAdjointEig", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchSelfAdjointEigV2<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    computeV: Bool = true
+) -> (e: Tensor<T>, v: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("BatchSelfAdjointEigV2", nOutputs)
+    op.updateAttribute("compute_v", computeV)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func batchSvd<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    computeUv: Bool = true,
+    fullMatrices: Bool = false
+) -> (s: Tensor<T>, u: Tensor<T>, v: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("BatchSvd", nOutputs)
+    op.updateAttribute("compute_uv", computeUv)
+    op.updateAttribute("full_matrices", fullMatrices)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// BatchToSpace for 4-D tensors of type T.
+///
+/// This is a legacy version of the more general BatchToSpaceND.
+///
+/// Rearranges (permutes) data from batch into blocks of spatial data, followed by
+/// cropping. This is the reverse transformation of SpaceToBatch. More specifically,
+/// this op outputs a copy of the input tensor where values from the `batch`
+/// dimension are moved in spatial blocks to the `height` and `width` dimensions,
+/// followed by cropping along the `height` and `width` dimensions.
+///
+/// - Parameters:
+///     - input: 4-D tensor with shape
+///         `[batch*block_size*block_size, height_pad/block_size, width_pad/block_size,
+///           depth]`. Note that the batch size of the input tensor must be divisible by
+///         `block_size * block_size`.
+///     - crops: 2-D tensor of non-negative integers with shape `[2, 2]`. It specifies
+///         how many elements to crop from the intermediate result across the spatial
+///         dimensions as follows:
+///
+///             crops = [[crop_top, crop_bottom], [crop_left, crop_right]]
+///
+/// - Output output: 4-D with shape `[batch, height, width, depth]`, where:
+///
+///           height = height_pad - crop_top - crop_bottom
+///           width = width_pad - crop_left - crop_right
+///
+///     The attr `block_size` must be greater than one. It indicates the block size.
+///
+///     Some examples:
+///
+///     (1) For the following input of shape `[4, 1, 1, 1]` and block_size of 2:
+///
+///     ```
+///     [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+///     ```
+///
+///     The output tensor has shape `[1, 2, 2, 1]` and value:
+///
+///     ```
+///     x = [[[[1], [2]], [[3], [4]]]]
+///     ```
+///
+///     (2) For the following input of shape `[4, 1, 1, 3]` and block_size of 2:
+///
+///     ```
+///     [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
+///     ```
+///
+///     The output tensor has shape `[1, 2, 2, 3]` and value:
+///
+///     ```
+///     x = [[[[1, 2, 3], [4, 5, 6]],
+///           [[7, 8, 9], [10, 11, 12]]]]
+///     ```
+///
+///     (3) For the following input of shape `[4, 2, 2, 1]` and block_size of 2:
+///
+///     ```
+///     x = [[[[1], [3]], [[9], [11]]],
+///          [[[2], [4]], [[10], [12]]],
+///          [[[5], [7]], [[13], [15]]],
+///          [[[6], [8]], [[14], [16]]]]
+///     ```
+///
+///     The output tensor has shape `[1, 4, 4, 1]` and value:
+///
+///     ```
+///     x = [[[[1],   [2],  [3],  [4]],
+///          [[5],   [6],  [7],  [8]],
+///          [[9],  [10], [11],  [12]],
+///          [[13], [14], [15],  [16]]]]
+///     ```
+///
+///     (4) For the following input of shape `[8, 1, 2, 1]` and block_size of 2:
+///
+///     ```
+///     x = [[[[1], [3]]], [[[9], [11]]], [[[2], [4]]], [[[10], [12]]],
+///          [[[5], [7]]], [[[13], [15]]], [[[6], [8]]], [[[14], [16]]]]
+///     ```
+///
+///     The output tensor has shape `[2, 2, 4, 1]` and value:
+///
+///     ```
+///     x = [[[[1], [3]], [[5], [7]]],
+///          [[[2], [4]], [[10], [12]]],
+///          [[[5], [7]], [[13], [15]]],
+///          [[[6], [8]], [[14], [16]]]]
+///     ```
+@inlinable @inline(__always)
+public static func batchToSpace<
+    T: TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    crops: Tensor<Tidx>,
+    blockSize: Int64
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchToSpace", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("block_size", blockSize)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(crops)
+    return op.execute(Int(1))
+}
+
+/// BatchToSpace for N-D tensors of type T.
+///
+/// This operation reshapes the "batch" dimension 0 into `M + 1` dimensions of shape
+/// `block_shape + [batch]`, interleaves these blocks back into the grid defined by
+/// the spatial dimensions `[1, ..., M]`, to obtain a result with the same rank as
+/// the input.  The spatial dimensions of this intermediate result are then
+/// optionally cropped according to `crops` to produce the output.  This is the
+/// reverse of SpaceToBatch.  See below for a precise description.
+///
+/// - Parameters:
+///     - input: N-D with shape `input_shape = [batch] + spatial_shape + remaining_shape`,
+///         where spatial_shape has M dimensions.
+///     - block_shape: 1-D with shape `[M]`, all values must be >= 1.
+///     - crops: 2-D with shape `[M, 2]`, all values must be >= 0.
+///           `crops[i] = [crop_start, crop_end]` specifies the amount to crop from input
+///           dimension `i + 1`, which corresponds to spatial dimension `i`.  It is
+///           required that
+///           `crop_start[i] + crop_end[i] <= block_shape[i] * input_shape[i + 1]`.
+///
+///         This operation is equivalent to the following steps:
+///
+///         1. Reshape `input` to `reshaped` of shape:
+///              [block_shape[0], ..., block_shape[M-1],
+///               batch / prod(block_shape),
+///               input_shape[1], ..., input_shape[N-1]]
+///
+///         2. Permute dimensions of `reshaped` to produce `permuted` of shape
+///              [batch / prod(block_shape),
+///
+///               input_shape[1], block_shape[0],
+///               ...,
+///               input_shape[M], block_shape[M-1],
+///
+///               input_shape[M+1], ..., input_shape[N-1]]
+///
+///         3. Reshape `permuted` to produce `reshaped_permuted` of shape
+///              [batch / prod(block_shape),
+///
+///               input_shape[1] * block_shape[0],
+///               ...,
+///               input_shape[M] * block_shape[M-1],
+///
+///               input_shape[M+1],
+///               ...,
+///               input_shape[N-1]]
+///
+///         4. Crop the start and end of dimensions `[1, ..., M]` of
+///            `reshaped_permuted` according to `crops` to produce the output of shape:
+///              [batch / prod(block_shape),
+///
+///               input_shape[1] * block_shape[0] - crops[0,0] - crops[0,1],
+///               ...,
+///               input_shape[M] * block_shape[M-1] - crops[M-1,0] - crops[M-1,1],
+///
+///               input_shape[M+1], ..., input_shape[N-1]]
+///
+///         Some examples:
+///
+///         (1) For the following input of shape `[4, 1, 1, 1]`, `block_shape = [2, 2]`, and
+///             `crops = [[0, 0], [0, 0]]`:
+///
+///         ```
+///         [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+///         ```
+///
+///         The output tensor has shape `[1, 2, 2, 1]` and value:
+///
+///         ```
+///         x = [[[[1], [2]], [[3], [4]]]]
+///         ```
+///
+///         (2) For the following input of shape `[4, 1, 1, 3]`, `block_shape = [2, 2]`, and
+///             `crops = [[0, 0], [0, 0]]`:
+///
+///         ```
+///         [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
+///         ```
+///
+///         The output tensor has shape `[1, 2, 2, 3]` and value:
+///
+///         ```
+///         x = [[[[1, 2, 3], [4, 5, 6]],
+///               [[7, 8, 9], [10, 11, 12]]]]
+///         ```
+///
+///         (3) For the following input of shape `[4, 2, 2, 1]`, `block_shape = [2, 2]`, and
+///             `crops = [[0, 0], [0, 0]]`:
+///
+///         ```
+///         x = [[[[1], [3]], [[9], [11]]],
+///              [[[2], [4]], [[10], [12]]],
+///              [[[5], [7]], [[13], [15]]],
+///              [[[6], [8]], [[14], [16]]]]
+///         ```
+///
+///         The output tensor has shape `[1, 4, 4, 1]` and value:
+///
+///         ```
+///         x = [[[[1],   [2],  [3],  [4]],
+///              [[5],   [6],  [7],  [8]],
+///              [[9],  [10], [11],  [12]],
+///              [[13], [14], [15],  [16]]]]
+///         ```
+///
+///         (4) For the following input of shape `[8, 1, 3, 1]`, `block_shape = [2, 2]`, and
+///             `crops = [[0, 0], [2, 0]]`:
+///
+///         ```
+///         x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
+///              [[[0], [2], [4]]], [[[0], [10], [12]]],
+///              [[[0], [5], [7]]], [[[0], [13], [15]]],
+///              [[[0], [6], [8]]], [[[0], [14], [16]]]]
+///         ```
+///
+///         The output tensor has shape `[2, 2, 4, 1]` and value:
+///
+///         ```
+///         x = [[[[1],   [2],  [3],  [4]],
+///               [[5],   [6],  [7],  [8]]],
+///              [[[9],  [10], [11],  [12]],
+///               [[13], [14], [15],  [16]]]]
+///         ```
+@inlinable @inline(__always)
+public static func batchToSpaceND<
+    T: TensorFlowScalar,
+    TblockShape: BinaryInteger & TensorFlowScalar,
+    Tcrops: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    blockShape: Tensor<TblockShape>,
+    crops: Tensor<Tcrops>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BatchToSpaceND", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tblock_shape", TblockShape.tensorFlowDataType)
+    op.updateAttribute("Tcrops", Tcrops.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(blockShape)
+    op.addInput(crops)
+    return op.execute(Int(1))
+}
+
+/// Computes the Bessel i0e function of `x` element-wise.
+///
+/// Exponentially scaled modified Bessel function of order 0 defined as
+/// `bessel_i0e(x) = exp(-abs(x)) bessel_i0(x)`.
+///
+/// This function is faster and numerically stabler than `bessel_i0(x)`.
+@inlinable @inline(__always)
+public static func besselI0e<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BesselI0e", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the Bessel i1e function of `x` element-wise.
+///
+/// Exponentially scaled modified Bessel function of order 0 defined as
+/// `bessel_i1e(x) = exp(-abs(x)) bessel_i1(x)`.
+///
+/// This function is faster and numerically stabler than `bessel_i1(x)`.
+@inlinable @inline(__always)
+public static func besselI1e<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BesselI1e", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Compute the regularized incomplete beta integral \\(I_x(a, b)\\).
+///
+/// The regularized incomplete beta integral is defined as:
+///
+///
+/// \\(I_x(a, b) = \frac{B(x; a, b)}{B(a, b)}\\)
+///
+/// where
+///
+///
+/// \\(B(x; a, b) = \int_0^x t^{a-1} (1 - t)^{b-1} dt\\)
+///
+///
+/// is the incomplete beta function and \\(B(a, b)\\) is the *complete*
+/// beta function.
+@inlinable @inline(__always)
+public static func betainc<T: FloatingPoint & TensorFlowScalar>(
+    _ a: Tensor<T>,
+    _ b: Tensor<T>,
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Betainc", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    op.addInput(b)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Adds `bias` to `value`.
+///
+/// This is a special case of `tf.add` where `bias` is restricted to be 1-D.
+/// Broadcasting is supported, so `value` may have any number of dimensions.
+///
+/// - Parameters:
+///     - value: Any number of dimensions.
+///     - bias: 1-D with size the last dimension of `value`.
+///
+/// - Attr data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the bias tensor will be added to the last dimension
+///     of the value tensor.
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, in_channels, in_height, in_width].
+///     The tensor will be added to "in_channels", the third-to-the-last
+///         dimension.
+///
+/// - Output output: Broadcasted sum of `value` and `bias`.
+@inlinable @inline(__always)
+public static func biasAdd<T: Numeric & TensorFlowScalar>(
+    value: Tensor<T>,
+    bias: Tensor<T>,
+    dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BiasAdd", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.addInput(value)
+    op.addInput(bias)
+    return op.execute(Int(1))
+}
+
+/// The backward operation for "BiasAdd" on the "bias" tensor.
+///
+/// It accumulates all the values from out_backprop into the feature dimension.
+/// For NHWC data format, the feature dimension is the last. For NCHW data format,
+/// the feature dimension is the third-to-last.
+///
+/// - Parameter out_backprop: Any number of dimensions.
+///
+/// - Attr data_format: Specify the data format of the input and output data. With the
+///     default format "NHWC", the bias tensor will be added to the last dimension
+///     of the value tensor.
+///     Alternatively, the format could be "NCHW", the data storage order of:
+///         [batch, in_channels, in_height, in_width].
+///     The tensor will be added to "in_channels", the third-to-the-last
+///         dimension.
+///
+/// - Output output: 1-D with size the feature dimension of `out_backprop`.
+@inlinable @inline(__always)
+public static func biasAddGrad<T: Numeric & TensorFlowScalar>(
+    outBackprop: Tensor<T>,
+    dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BiasAddGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.addInput(outBackprop)
+    return op.execute(Int(1))
+}
+
+/// Adds `bias` to `value`.
+///
+/// This is a deprecated version of BiasAdd and will be soon removed.
+///
+/// This is a special case of `tf.add` where `bias` is restricted to be 1-D.
+/// Broadcasting is supported, so `value` may have any number of dimensions.
+///
+/// - Parameters:
+///     - value: Any number of dimensions.
+///     - bias: 1-D with size the last dimension of `value`.
+///
+/// - Output output: Broadcasted sum of `value` and `bias`.
+@inlinable @inline(__always)
+public static func biasAddV1<T: Numeric & TensorFlowScalar>(
+    value: Tensor<T>,
+    bias: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BiasAddV1", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(value)
+    op.addInput(bias)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func binary<T: TensorFlowScalar>(
+    _ a: Tensor<T>,
+    _ b: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Binary", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    op.addInput(b)
+    return op.execute(Int(1))
+}
+
+/// Counts the number of occurrences of each value in an integer array.
+///
+/// Outputs a vector with length `size` and the same dtype as `weights`. If
+/// `weights` are empty, then index `i` stores the number of times the value `i` is
+/// counted in `arr`. If `weights` are non-empty, then index `i` stores the sum of
+/// the value in `weights` at each index where the corresponding value in `arr` is
+/// `i`.
+///
+/// Values in `arr` outside of the range [0, size) are ignored.
+///
+/// - Parameters:
+///     - arr: int32 `Tensor`.
+///     - size: non-negative int32 scalar `Tensor`.
+///     - weights: is an int32, int64, float32, or float64 `Tensor` with the same
+///         shape as `arr`, or a length-0 `Tensor`, in which case it acts as all weights
+///         equal to 1.
+///
+/// - Output bins: 1D `Tensor` with length equal to `size`. The counts or summed weights for
+///     each value in the range [0, size).
+@inlinable @inline(__always)
+public static func bincount<T: Numeric & TensorFlowScalar>(
+    arr: Tensor<Int32>,
+    size: Tensor<Int32>,
+    weights: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Bincount", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(arr)
+    op.addInput(size)
+    op.addInput(weights)
+    return op.execute(Int(1))
+}
+
+/// Bitcasts a tensor from one type to another without copying data.
+///
+/// Given a tensor `input`, this operation returns a tensor that has the same buffer
+/// data as `input` with datatype `type`.
+///
+/// If the input datatype `T` is larger than the output datatype `type` then the
+/// shape changes from [...] to [..., sizeof(`T`)/sizeof(`type`)].
+///
+/// If `T` is smaller than `type`, the operator requires that the rightmost
+/// dimension be equal to sizeof(`type`)/sizeof(`T`). The shape then goes from
+/// [..., sizeof(`type`)/sizeof(`T`)] to [...].
+///
+/// tf.bitcast() and tf.cast() work differently when real dtype is casted as a complex dtype
+/// (e.g. tf.complex64 or tf.complex128) as tf.cast() make imaginary part 0 while tf.bitcast()
+/// gives module error.
+/// For example,
+///
+/// Example 1:
+/// ```python
+/// >>> a = [1., 2., 3.]
+/// >>> equality_bitcast = tf.bitcast(a,tf.complex128)
+/// tensorflow.python.framework.errors_impl.InvalidArgumentError: Cannot bitcast from float to complex128: shape [3] [Op:Bitcast]
+/// >>> equality_cast = tf.cast(a,tf.complex128)
+/// >>> print(equality_cast)
+/// tf.Tensor([1.+0.j 2.+0.j 3.+0.j], shape=(3,), dtype=complex128)
+/// ```
+/// Example 2:
+/// ```python
+/// >>> tf.bitcast(tf.constant(0xffffffff, dtype=tf.uint32), tf.uint8)
+/// <tf.Tensor: ... shape=(4,), dtype=uint8, numpy=array([255, 255, 255, 255], dtype=uint8)>
+/// ```
+/// Example 3:
+/// ```python
+/// >>> x = [1., 2., 3.]
+/// >>> y = [0., 2., 3.]
+/// >>> equality= tf.equal(x,y)
+/// >>> equality_cast = tf.cast(equality,tf.float32)
+/// >>> equality_bitcast = tf.bitcast(equality_cast,tf.uint8)
+/// >>> print(equality)
+/// tf.Tensor([False True True], shape=(3,), dtype=bool)
+/// >>> print(equality_cast)
+/// tf.Tensor([0. 1. 1.], shape=(3,), dtype=float32)
+/// >>> print(equality_bitcast)
+/// tf.Tensor(
+/// [[ 0 0 0 0]
+///  [ 0 0 128 63]
+///  [ 0 0 128 63]], shape=(3, 4), dtype=uint8)
+/// ```
+///
+/// *NOTE*: Bitcast is implemented as a low-level cast, so machines with different
+/// endian orderings will give different results.
+@inlinable @inline(__always)
+public static func bitcast<
+    T: Numeric & TensorFlowScalar,
+    Type: Numeric & TensorFlowScalar
+>(
+    _ input: Tensor<T>
+) -> Tensor<Type> {
+  let nOutputs = Int(1)
+    let op = makeOp("Bitcast", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("type", Type.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Elementwise computes the bitwise AND of `x` and `y`.
+///
+/// The result will have those bits set, that are set in both `x` and `y`. The
+/// computation is performed on the underlying representations of `x` and `y`.
+@inlinable @inline(__always)
+public static func bitwiseAnd<T: BinaryInteger & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BitwiseAnd", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Elementwise computes the bitwise OR of `x` and `y`.
+///
+/// The result will have those bits set, that are set in `x`, `y` or both. The
+/// computation is performed on the underlying representations of `x` and `y`.
+@inlinable @inline(__always)
+public static func bitwiseOr<T: BinaryInteger & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BitwiseOr", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Elementwise computes the bitwise XOR of `x` and `y`.
+///
+/// The result will have those bits set, that are different in `x` and `y`. The
+/// computation is performed on the underlying representations of `x` and `y`.
+@inlinable @inline(__always)
+public static func bitwiseXor<T: BinaryInteger & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BitwiseXor", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Computes the LSTM cell forward propagation for all the time steps.
+///
+/// This is equivalent to applying LSTMBlockCell in a loop, like so:
+///
+/// ```python
+/// for x1 in unpack(x):
+///   i1, cs1, f1, o1, ci1, co1, h1 = LSTMBlock(
+///     x1, cs_prev, h_prev, w, wci, wcf, wco, b)
+///   cs_prev = cs1
+///   h_prev = h1
+///   i.append(i1)
+///   cs.append(cs1)
+///   f.append(f1)
+///   o.append(o1)
+///   ci.append(ci1)
+///   co.append(co1)
+///   h.append(h1)
+/// return pack(i), pack(cs), pack(f), pack(o), pack(ci), pack(ch), pack(h)
+/// ```
+///
+/// - Parameters:
+///     - seq_len_max: Maximum time length actually used by this input. Outputs are padded
+///         with zeros beyond this length.
+///     - x: The sequence input to the LSTM, shape (timelen, batch_size, num_inputs).
+///     - cs_prev: Value of the initial cell state.
+///     - h_prev: Initial output of cell (to be used for peephole).
+///     - w: The weight matrix.
+///     - wci: The weight matrix for input gate peephole connection.
+///     - wcf: The weight matrix for forget gate peephole connection.
+///     - wco: The weight matrix for output gate peephole connection.
+///     - b: The bias vector.
+///
+/// - Attrs:
+///     - forget_bias: The forget gate bias.
+///     - cell_clip: Value to clip the 'cs' value to.
+///     - use_peephole: Whether to use peephole weights.
+///
+/// - Outputs:
+///     - i: The input gate over the whole time sequence.
+///     - cs: The cell state before the tanh over the whole time sequence.
+///     - f: The forget gate over the whole time sequence.
+///     - o: The output gate over the whole time sequence.
+///     - ci: The cell input over the whole time sequence.
+///     - co: The cell after the tanh over the whole time sequence.
+///     - h: The output h vector over the whole time sequence.
+@inlinable @inline(__always)
+public static func blockLSTM<T: FloatingPoint & TensorFlowScalar>(
+    seqLenMax: Tensor<Int64>,
+    _ x: Tensor<T>,
+    csPrev: Tensor<T>,
+    hPrev: Tensor<T>,
+    w: Tensor<T>,
+    wci: Tensor<T>,
+    wcf: Tensor<T>,
+    wco: Tensor<T>,
+    _ b: Tensor<T>,
+    forgetBias: Double = 1,
+    cellClip: Double = 3,
+    usePeephole: Bool = false
+) -> (i: Tensor<T>, cs: Tensor<T>, f: Tensor<T>, o: Tensor<T>, ci: Tensor<T>, co: Tensor<T>, h: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("BlockLSTM", nOutputs)
+    op.updateAttribute("forget_bias", forgetBias)
+    op.updateAttribute("cell_clip", cellClip)
+    op.updateAttribute("use_peephole", usePeephole)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(seqLenMax)
+    op.addInput(x)
+    op.addInput(csPrev)
+    op.addInput(hPrev)
+    op.addInput(w)
+    op.addInput(wci)
+    op.addInput(wcf)
+    op.addInput(wco)
+    op.addInput(b)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Computes the LSTM cell backward propagation for the entire time sequence.
+///
+/// This implementation is to be used in conjunction of LSTMBlock.
+///
+/// - Parameters:
+///     - seq_len_max: Maximum time length actually used by this input. Outputs are padded
+///         with zeros beyond this length.
+///     - x: The sequence input to the LSTM, shape (timelen, batch_size, num_inputs).
+///     - cs_prev: Value of the initial cell state.
+///     - h_prev: Initial output of cell (to be used for peephole).
+///     - w: The weight matrix.
+///     - wci: The weight matrix for input gate peephole connection.
+///     - wcf: The weight matrix for forget gate peephole connection.
+///     - wco: The weight matrix for output gate peephole connection.
+///     - b: The bias vector.
+///     - i: The input gate over the whole time sequence.
+///     - cs: The cell state before the tanh over the whole time sequence.
+///     - f: The forget gate over the whole time sequence.
+///     - o: The output gate over the whole time sequence.
+///     - ci: The cell input over the whole time sequence.
+///     - co: The cell after the tanh over the whole time sequence.
+///     - h: The output h vector over the whole time sequence.
+///     - cs_grad: The current gradient of cs.
+///     - h_grad: The gradient of h vector.
+///
+/// - Attr use_peephole: Whether to use peephole weights.
+///
+/// - Outputs:
+///     - x_grad: The gradient of x to be back-propped.
+///     - cs_prev_grad: The gradient of cs_prev to be back-propped.
+///     - h_prev_grad: The gradient of h_prev to be back-propped.
+///     - w_grad: The gradient for w to be back-propped.
+///     - wci_grad: The gradient for wci to be back-propped.
+///     - wcf_grad: The gradient for wcf to be back-propped.
+///     - wco_grad: The gradient for wco to be back-propped.
+///     - b_grad: The gradient for w to be back-propped.
+@inlinable @inline(__always)
+public static func blockLSTMGrad<T: FloatingPoint & TensorFlowScalar>(
+    seqLenMax: Tensor<Int64>,
+    _ x: Tensor<T>,
+    csPrev: Tensor<T>,
+    hPrev: Tensor<T>,
+    w: Tensor<T>,
+    wci: Tensor<T>,
+    wcf: Tensor<T>,
+    wco: Tensor<T>,
+    _ b: Tensor<T>,
+    i: Tensor<T>,
+    cs: Tensor<T>,
+    f: Tensor<T>,
+    o: Tensor<T>,
+    ci: Tensor<T>,
+    co: Tensor<T>,
+    h: Tensor<T>,
+    csGrad: Tensor<T>,
+    hGrad: Tensor<T>,
+    usePeephole: Bool
+) -> (xGrad: Tensor<T>, csPrevGrad: Tensor<T>, hPrevGrad: Tensor<T>, wGrad: Tensor<T>, wciGrad: Tensor<T>, wcfGrad: Tensor<T>, wcoGrad: Tensor<T>, bGrad: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("BlockLSTMGrad", nOutputs)
+    op.updateAttribute("use_peephole", usePeephole)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(seqLenMax)
+    op.addInput(x)
+    op.addInput(csPrev)
+    op.addInput(hPrev)
+    op.addInput(w)
+    op.addInput(wci)
+    op.addInput(wcf)
+    op.addInput(wco)
+    op.addInput(b)
+    op.addInput(i)
+    op.addInput(cs)
+    op.addInput(f)
+    op.addInput(o)
+    op.addInput(ci)
+    op.addInput(co)
+    op.addInput(h)
+    op.addInput(csGrad)
+    op.addInput(hGrad)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Aggregates the summary of accumulated stats for the batch.
+///
+/// The summary stats contains gradients and hessians accumulated for each node, feature dimension id and bucket.
+///
+/// - Parameters:
+///     - node_ids: int32; Rank 1 Tensor containing node ids for each example, shape [batch_size].
+///     - gradients: float32; Rank 2 Tensor (shape=[batch_size, logits_dimension]) with gradients for each example.
+///     - hessians: float32; Rank 2 Tensor (shape=[batch_size, hessian_dimension]) with hessians for each example.
+///     - feature: int32; Rank 2 feature Tensors (shape=[batch_size, feature_dimension]).
+///
+/// - Attrs:
+///     - max_splits: int; the maximum number of splits possible in the whole tree.
+///     - num_buckets: int; equals to the maximum possible value of bucketized feature.
+///
+/// - Output stats_summary: output Rank 4 Tensor (shape=[splits, feature_dimension, buckets, logits_dimension + hessian_dimension])
+///     containing accumulated stats for each node, feature dimension and bucket.
+@inlinable @inline(__always)
+public static func boostedTreesAggregateStats(
+    nodeIds: Tensor<Int32>,
+    gradients: Tensor<Float>,
+    hessians: Tensor<Float>,
+    feature: Tensor<Int32>,
+    maxSplits: Int64,
+    numBuckets: Int64
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("BoostedTreesAggregateStats", nOutputs)
+    op.updateAttribute("max_splits", maxSplits)
+    op.updateAttribute("num_buckets", numBuckets)
+    op.addInput(nodeIds)
+    op.addInput(gradients)
+    op.addInput(hessians)
+    op.addInput(feature)
+    return op.execute(Int(1))
+}
+
+/// Bucketize each feature based on bucket boundaries.
+///
+/// An op that returns a list of float tensors, where each tensor represents the
+/// bucketized values for a single feature.
+///
+/// - Parameters:
+///     - float_values: float; List of Rank 1 Tensor each containing float values for a single feature.
+///     - bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a single
+///         feature.
+///
+/// - Attr num_features: inferred int; number of features.
+///
+/// - Output buckets: int; List of Rank 1 Tensors each containing the bucketized values for a single feature.
+@inlinable @inline(__always)
+public static func boostedTreesBucketize(
+    floatValues: [Tensor<Float>],
+    bucketBoundaries: [Tensor<Float>]
+) -> [Tensor<Int32>] {
+  let nOutputs = Int(floatValues.count)
+    let op = makeOp("BoostedTreesBucketize", nOutputs)
+    op.updateAttribute("num_features", floatValues.count)
+    op.addInputList(floatValues)
+    op.addInputList(bucketBoundaries)
+    return op.execute(Int(floatValues.count))
+}
+
+/// Calculates gains for each feature and returns the best possible split information for the feature.
+///
+/// The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature.
+///
+/// It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split.
+///
+/// In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features).
+///
+/// The output shapes are compatible in a way that the first dimension of all tensors are the same and equal to the number of possible split nodes for each feature.
+///
+/// - Parameters:
+///     - node_id_range: A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive).
+///     - stats_summary: A Rank 4 tensor (#shape=[max_splits, feature_dims, bucket, stats_dims]) for accumulated stats summary (gradient/hessian) per node, per dimension, per buckets for each feature.
+///         The first dimension of the tensor is the maximum number of splits, and thus not all elements of it will be used, but only the indexes specified by node_ids will be used.
+///     - l1: l1 regularization factor on leaf weights, per instance based.
+///     - l2: l2 regularization factor on leaf weights, per instance based.
+///     - tree_complexity: adjustment to the gain, per leaf based.
+///     - min_node_weight: mininum avg of hessians in a node before required for the node to be considered for splitting.
+///
+/// - Attrs:
+///     - logits_dimension: The dimension of logit, i.e., number of classes.
+///     - split_type: A string indicating if this Op should perform inequality split or equality split.
+///
+/// - Outputs:
+///     - node_ids: A Rank 1 tensors indicating possible split node ids for each feature. The length of the list is num_features, but each tensor has different size as each feature provides different possible nodes. See above for details like shapes and sizes.
+///     - gains: A Rank 1 tensors indicating the best gains for each feature to split for certain nodes. See above for details like shapes and sizes.
+///     - feature_dimensions: A Rank 1 tensors indicating the best feature dimension for each feature to split for certain nodes if the feature is multi-dimension. See above for details like shapes and sizes.
+///     - thresholds: A Rank 1 tensors indicating the bucket id to compare with (as a threshold) for split in each node. See above for details like shapes and sizes.
+///     - left_node_contribs: A Rank 2 tensors indicating the contribution of the left nodes when branching from parent nodes (given by the tensor element in the output node_ids_list) to the left direction by the given threshold for each feature. This value will be used to make the left node value by adding to the parent node value. Second dimension size is 1 for 1-dimensional logits, but would be larger for multi-class problems. See above for details like shapes and sizes.
+///     - right_node_contribs: A Rank 2 tensors, with the same shape/conditions as left_node_contribs_list, but just that the value is for the right node.
+///     - split_with_default_directions: A Rank 1 tensors indicating the which direction to go if data is missing. See above for details like shapes and sizes.
+@inlinable @inline(__always)
+public static func boostedTreesCalculateBestFeatureSplit(
+    nodeIdRange: Tensor<Int32>,
+    statsSummary: Tensor<Float>,
+    l1: Tensor<Float>,
+    l2: Tensor<Float>,
+    treeComplexity: Tensor<Float>,
+    minNodeWeight: Tensor<Float>,
+    logitsDimension: Int64,
+    splitType: SplitType = .inequality
+) -> (nodeIds: Tensor<Int32>, gains: Tensor<Float>, featureDimensions: Tensor<Int32>, thresholds: Tensor<Int32>, leftNodeContribs: Tensor<Float>, rightNodeContribs: Tensor<Float>, splitWithDefaultDirections: StringTensor) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("BoostedTreesCalculateBestFeatureSplit", nOutputs)
+    op.updateAttribute("logits_dimension", logitsDimension)
+    op.updateAttribute("split_type", splitType.cName)
+    op.addInput(nodeIdRange)
+    op.addInput(statsSummary)
+    op.addInput(l1)
+    op.addInput(l2)
+    op.addInput(treeComplexity)
+    op.addInput(minNodeWeight)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Calculates gains for each feature and returns the best possible split information for the feature.
+///
+/// The split information is the best threshold (bucket id), gains and left/right node contributions per node for each feature.
+///
+/// It is possible that not all nodes can be split on each feature. Hence, the list of possible nodes can differ between the features. Therefore, we return `node_ids_list` for each feature, containing the list of nodes that this feature can be used to split.
+///
+/// In this manner, the output is the best split per features and per node, so that it needs to be combined later to produce the best split for each node (among all possible features).
+///
+/// The length of output lists are all of the same length, `num_features`.
+/// The output shapes are compatible in a way that the first dimension of all tensors of all lists are the same and equal to the number of possible split nodes for each feature.
+///
+/// - Parameters:
+///     - node_id_range: A Rank 1 tensor (shape=[2]) to specify the range [first, last) of node ids to process within `stats_summary_list`. The nodes are iterated between the two nodes specified by the tensor, as like `for node_id in range(node_id_range[0], node_id_range[1])` (Note that the last index node_id_range[1] is exclusive).
+///     - stats_summary_list: A list of Rank 3 tensor (#shape=[max_splits, bucket, 2]) for accumulated stats summary (gradient/hessian) per node per buckets for each feature. The first dimension of the tensor is the maximum number of splits, and thus not all elements of it will be used, but only the indexes specified by node_ids will be used.
+///     - l1: l1 regularization factor on leaf weights, per instance based.
+///     - l2: l2 regularization factor on leaf weights, per instance based.
+///     - tree_complexity: adjustment to the gain, per leaf based.
+///     - min_node_weight: mininum avg of hessians in a node before required for the node to be considered for splitting.
+///
+/// - Attrs:
+///     - max_splits: the number of nodes that can be split in the whole tree. Used as a dimension of output tensors.
+///     - num_features: inferred from the size of `stats_summary_list`; the number of total features.
+///
+/// - Outputs:
+///     - node_ids_list: An output list of Rank 1 tensors indicating possible split node ids for each feature. The length of the list is num_features, but each tensor has different size as each feature provides different possible nodes. See above for details like shapes and sizes.
+///     - gains_list: An output list of Rank 1 tensors indicating the best gains for each feature to split for certain nodes. See above for details like shapes and sizes.
+///     - thresholds_list: An output list of Rank 1 tensors indicating the bucket id to compare with (as a threshold) for split in each node. See above for details like shapes and sizes.
+///     - left_node_contribs_list: A list of Rank 2 tensors indicating the contribution of the left nodes when branching from parent nodes (given by the tensor element in the output node_ids_list) to the left direction by the given threshold for each feature. This value will be used to make the left node value by adding to the parent node value. Second dimension size is 1 for 1-dimensional logits, but would be larger for multi-class problems. See above for details like shapes and sizes.
+///     - right_node_contribs_list: A list of Rank 2 tensors, with the same shape/conditions as left_node_contribs_list, but just that the value is for the right node.
+@inlinable @inline(__always)
+public static func boostedTreesCalculateBestGainsPerFeature(
+    nodeIdRange: Tensor<Int32>,
+    statsSummaryList: [Tensor<Float>],
+    l1: Tensor<Float>,
+    l2: Tensor<Float>,
+    treeComplexity: Tensor<Float>,
+    minNodeWeight: Tensor<Float>,
+    maxSplits: Int64
+) -> (nodeIdsList: [Tensor<Int32>], gainsList: [Tensor<Float>], thresholdsList: [Tensor<Int32>], leftNodeContribsList: [Tensor<Float>], rightNodeContribsList: [Tensor<Float>]) {
+  let nOutputs = Int(statsSummaryList.count) + Int(statsSummaryList.count) + Int(statsSummaryList.count) + Int(statsSummaryList.count) + Int(statsSummaryList.count)
+    let op = makeOp("BoostedTreesCalculateBestGainsPerFeature", nOutputs)
+    op.updateAttribute("max_splits", maxSplits)
+    op.updateAttribute("num_features", statsSummaryList.count)
+    op.addInput(nodeIdRange)
+    op.addInputList(statsSummaryList)
+    op.addInput(l1)
+    op.addInput(l2)
+    op.addInput(treeComplexity)
+    op.addInput(minNodeWeight)
+    return op.execute(Int(statsSummaryList.count), Int(statsSummaryList.count), Int(statsSummaryList.count), Int(statsSummaryList.count), Int(statsSummaryList.count))
+}
+
+/// Calculates the prior from the training data (the bias) and fills in the first node with the logits' prior. Returns a boolean indicating whether to continue centering.
+///
+/// - Parameters:
+///     - tree_ensemble_handle: Handle to the tree ensemble.
+///     - mean_gradients: A tensor with shape=[logits_dimension] with mean of gradients for a first node.
+///     - mean_hessians: A tensor with shape=[logits_dimension] mean of hessians for a first node.
+///     - l1: l1 regularization factor on leaf weights, per instance based.
+///     - l2: l2 regularization factor on leaf weights, per instance based.
+///
+/// - Output continue_centering: Bool, whether to continue bias centering.
+@inlinable @inline(__always)
+public static func boostedTreesCenterBias(
+    treeEnsembleHandle: ResourceHandle,
+    meanGradients: Tensor<Float>,
+    meanHessians: Tensor<Float>,
+    l1: Tensor<Float>,
+    l2: Tensor<Float>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("BoostedTreesCenterBias", nOutputs)
+    op.addInput(treeEnsembleHandle)
+    op.addInput(meanGradients)
+    op.addInput(meanHessians)
+    op.addInput(l1)
+    op.addInput(l2)
+    return op.execute(Int(1))
+}
+
+/// Creates a tree ensemble model and returns a handle to it.
+///
+/// - Parameters:
+///     - tree_ensemble_handle: Handle to the tree ensemble resource to be created.
+///     - stamp_token: Token to use as the initial value of the resource stamp.
+///     - tree_ensemble_serialized: Serialized proto of the tree ensemble.
+@inlinable @inline(__always)
+public static func boostedTreesCreateEnsemble(
+    treeEnsembleHandle: ResourceHandle,
+    stampToken: Tensor<Int64>,
+    treeEnsembleSerialized: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("BoostedTreesCreateEnsemble", nOutputs)
+    op.addInput(treeEnsembleHandle)
+    op.addInput(stampToken)
+    op.addInput(treeEnsembleSerialized)
+    op.execute()
+}
+
+/// Create the Resource for Quantile Streams.
+///
+/// - Parameters:
+///     - quantile_stream_resource_handle: resource; Handle to quantile stream resource.
+///     - epsilon: float; The required approximation error of the stream resource.
+///     - num_streams: int; The number of streams managed by the resource that shares the same epsilon.
+///
+/// - Attr max_elements: int; The maximum number of data points that can be fed to the stream.
+@inlinable @inline(__always)
+public static func boostedTreesCreateQuantileStreamResource(
+    quantileStreamResourceHandle: ResourceHandle,
+    epsilon: Tensor<Float>,
+    numStreams: Tensor<Int64>,
+    maxElements: Int64 = 1099511627776
+) {
+  let nOutputs = 0
+    let op = makeOp("BoostedTreesCreateQuantileStreamResource", nOutputs)
+    op.updateAttribute("max_elements", maxElements)
+    op.addInput(quantileStreamResourceHandle)
+    op.addInput(epsilon)
+    op.addInput(numStreams)
+    op.execute()
+}
+
+/// Deserializes a serialized tree ensemble config and replaces current tree
+///
+/// ensemble.
+///
+/// - Parameters:
+///     - tree_ensemble_handle: Handle to the tree ensemble.
+///     - stamp_token: Token to use as the new value of the resource stamp.
+///     - tree_ensemble_serialized: Serialized proto of the ensemble.
+@inlinable @inline(__always)
+public static func boostedTreesDeserializeEnsemble(
+    treeEnsembleHandle: ResourceHandle,
+    stampToken: Tensor<Int64>,
+    treeEnsembleSerialized: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("BoostedTreesDeserializeEnsemble", nOutputs)
+    op.addInput(treeEnsembleHandle)
+    op.addInput(stampToken)
+    op.addInput(treeEnsembleSerialized)
+    op.execute()
+}
+
+/// Creates a handle to a BoostedTreesEnsembleResource
+@inlinable @inline(__always)
+public static func boostedTreesEnsembleResourceHandleOp(
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("BoostedTreesEnsembleResourceHandleOp", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Debugging/model interpretability outputs for each example.
+///
+/// It traverses all the trees and computes debug metrics for individual examples, 
+/// such as getting split feature ids and logits after each split along the decision
+/// path used to compute directional feature contributions.
+///
+/// - Parameter bucketized_features: A list of rank 1 Tensors containing bucket id for each
+///     feature.
+///
+/// - Attrs:
+///     - num_bucketized_features: Inferred.
+///     - logits_dimension: scalar, dimension of the logits, to be used for constructing the protos in
+///         examples_debug_outputs_serialized.
+///
+/// - Output examples_debug_outputs_serialized: Output rank 1 Tensor containing a proto serialized as a string for each example.
+@inlinable @inline(__always)
+public static func boostedTreesExampleDebugOutputs(
+    treeEnsembleHandle: ResourceHandle,
+    bucketizedFeatures: [Tensor<Int32>],
+    logitsDimension: Int64
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("BoostedTreesExampleDebugOutputs", nOutputs)
+    op.updateAttribute("num_bucketized_features", bucketizedFeatures.count)
+    op.updateAttribute("logits_dimension", logitsDimension)
+    op.addInput(treeEnsembleHandle)
+    op.addInputList(bucketizedFeatures)
+    return op.execute(Int(1))
+}
+
+/// Retrieves the tree ensemble resource stamp token, number of trees and growing statistics.
+///
+/// - Parameter tree_ensemble_handle: Handle to the tree ensemble.
+///
+/// - Outputs:
+///     - stamp_token: Stamp token of the tree ensemble resource.
+///     - num_trees: The number of trees in the tree ensemble resource.
+///     - num_finalized_trees: The number of trees that were finished successfully.
+///     - num_attempted_layers: The number of layers we attempted to build (but not necessarily succeeded).
+///     - last_layer_nodes_range: Rank size 2 tensor that contains start and end ids of the nodes in the latest
+///         layer.
+@inlinable @inline(__always)
+public static func boostedTreesGetEnsembleStates(
+    treeEnsembleHandle: ResourceHandle
+) -> (stampToken: Tensor<Int64>, numTrees: Tensor<Int32>, numFinalizedTrees: Tensor<Int32>, numAttemptedLayers: Tensor<Int32>, lastLayerNodesRange: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("BoostedTreesGetEnsembleStates", nOutputs)
+    op.addInput(treeEnsembleHandle)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Makes the summary of quantiles for the batch.
+///
+/// An op that takes a list of tensors (one tensor per feature) and outputs the
+/// quantile summaries for each tensor.
+///
+/// - Parameters:
+///     - float_values: float; List of Rank 1 Tensors each containing values for a single feature.
+///     - example_weights: float; Rank 1 Tensor with weights per instance.
+///     - epsilon: float; The required maximum approximation error.
+///
+/// - Attr num_features: int; Inferred from the size of float_values.
+///     The number of float features.
+///
+/// - Output summaries: float; List of Rank 2 Tensors each containing the quantile summary
+///     (value, weight, min_rank, max_rank) of a single feature.
+@inlinable @inline(__always)
+public static func boostedTreesMakeQuantileSummaries(
+    floatValues: [Tensor<Float>],
+    exampleWeights: Tensor<Float>,
+    epsilon: Tensor<Float>
+) -> [Tensor<Float>] {
+  let nOutputs = Int(floatValues.count)
+    let op = makeOp("BoostedTreesMakeQuantileSummaries", nOutputs)
+    op.updateAttribute("num_features", floatValues.count)
+    op.addInputList(floatValues)
+    op.addInput(exampleWeights)
+    op.addInput(epsilon)
+    return op.execute(Int(floatValues.count))
+}
+
+/// Makes the summary of accumulated stats for the batch.
+///
+/// The summary stats contains gradients and hessians accumulated into the corresponding node and bucket for each example.
+///
+/// - Parameters:
+///     - node_ids: int32 Rank 1 Tensor containing node ids, which each example falls into for the requested layer.
+///     - gradients: float32; Rank 2 Tensor (shape=[#examples, 1]) for gradients.
+///     - hessians: float32; Rank 2 Tensor (shape=[#examples, 1]) for hessians.
+///     - bucketized_features_list: int32 list of Rank 1 Tensors, each containing the bucketized feature (for each feature column).
+///
+/// - Attrs:
+///     - max_splits: int; the maximum number of splits possible in the whole tree.
+///     - num_buckets: int; equals to the maximum possible value of bucketized feature.
+///     - num_features: int; inferred from the size of bucketized_features_list; the number of features.
+///
+/// - Output stats_summary: output Rank 4 Tensor (shape=[#features, #splits, #buckets, 2]) containing accumulated stats put into the corresponding node and bucket. The first index of 4th dimension refers to gradients, and the second to hessians.
+@inlinable @inline(__always)
+public static func boostedTreesMakeStatsSummary(
+    nodeIds: Tensor<Int32>,
+    gradients: Tensor<Float>,
+    hessians: Tensor<Float>,
+    bucketizedFeaturesList: [Tensor<Int32>],
+    maxSplits: Int64,
+    numBuckets: Int64
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("BoostedTreesMakeStatsSummary", nOutputs)
+    op.updateAttribute("max_splits", maxSplits)
+    op.updateAttribute("num_buckets", numBuckets)
+    op.updateAttribute("num_features", bucketizedFeaturesList.count)
+    op.addInput(nodeIds)
+    op.addInput(gradients)
+    op.addInput(hessians)
+    op.addInputList(bucketizedFeaturesList)
+    return op.execute(Int(1))
+}
+
+/// Runs multiple additive regression ensemble predictors on input instances and
+///
+/// computes the logits. It is designed to be used during prediction.
+/// It traverses all the trees and calculates the final score for each instance.
+///
+/// - Parameter bucketized_features: A list of rank 1 Tensors containing bucket id for each
+///     feature.
+///
+/// - Attrs:
+///     - num_bucketized_features: Inferred.
+///     - logits_dimension: scalar, dimension of the logits, to be used for partial logits
+///         shape.
+///
+/// - Output logits: Output rank 2 Tensor containing logits for each example.
+@inlinable @inline(__always)
+public static func boostedTreesPredict(
+    treeEnsembleHandle: ResourceHandle,
+    bucketizedFeatures: [Tensor<Int32>],
+    logitsDimension: Int64
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("BoostedTreesPredict", nOutputs)
+    op.updateAttribute("num_bucketized_features", bucketizedFeatures.count)
+    op.updateAttribute("logits_dimension", logitsDimension)
+    op.addInput(treeEnsembleHandle)
+    op.addInputList(bucketizedFeatures)
+    return op.execute(Int(1))
+}
+
+/// Add the quantile summaries to each quantile stream resource.
+///
+/// An op that adds a list of quantile summaries to a quantile stream resource. Each
+/// summary Tensor is rank 2, containing summaries (value, weight, min_rank, max_rank)
+/// for a single feature.
+///
+/// - Parameters:
+///     - quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
+///     - summaries: string; List of Rank 2 Tensor each containing the summaries for a single feature.
+@inlinable @inline(__always)
+public static func boostedTreesQuantileStreamResourceAddSummaries(
+    quantileStreamResourceHandle: ResourceHandle,
+    summaries: [Tensor<Float>]
+) {
+  let nOutputs = 0
+    let op = makeOp("BoostedTreesQuantileStreamResourceAddSummaries", nOutputs)
+    op.updateAttribute("num_features", summaries.count)
+    op.addInput(quantileStreamResourceHandle)
+    op.addInputList(summaries)
+    op.execute()
+}
+
+/// Deserialize bucket boundaries and ready flag into current QuantileAccumulator.
+///
+/// An op that deserializes bucket boundaries and are boundaries ready flag into current QuantileAccumulator.
+///
+/// - Parameters:
+///     - quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
+///     - bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a feature.
+///
+/// - Attr num_streams: inferred int; number of features to get bucket boundaries for.
+@inlinable @inline(__always)
+public static func boostedTreesQuantileStreamResourceDeserialize(
+    quantileStreamResourceHandle: ResourceHandle,
+    bucketBoundaries: [Tensor<Float>]
+) {
+  let nOutputs = 0
+    let op = makeOp("BoostedTreesQuantileStreamResourceDeserialize", nOutputs)
+    op.updateAttribute("num_streams", bucketBoundaries.count)
+    op.addInput(quantileStreamResourceHandle)
+    op.addInputList(bucketBoundaries)
+    op.execute()
+}
+
+/// Flush the summaries for a quantile stream resource.
+///
+/// An op that flushes the summaries for a quantile stream resource.
+///
+/// - Parameters:
+///     - quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
+///     - num_buckets: int; approximate number of buckets unless using generate_quantiles.
+///
+/// - Attr generate_quantiles: bool; If True, the output will be the num_quantiles for each stream where the ith
+///     entry is the ith quantile of the input with an approximation error of epsilon.
+///     Duplicate values may be present.
+///     If False, the output will be the points in the histogram that we got which roughly
+///     translates to 1/epsilon boundaries and without any duplicates.
+///     Default to False.
+@inlinable @inline(__always)
+public static func boostedTreesQuantileStreamResourceFlush(
+    quantileStreamResourceHandle: ResourceHandle,
+    numBuckets: Tensor<Int64>,
+    generateQuantiles: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("BoostedTreesQuantileStreamResourceFlush", nOutputs)
+    op.updateAttribute("generate_quantiles", generateQuantiles)
+    op.addInput(quantileStreamResourceHandle)
+    op.addInput(numBuckets)
+    op.execute()
+}
+
+/// Generate the bucket boundaries for each feature based on accumulated summaries.
+///
+/// An op that returns a list of float tensors for a quantile stream resource. Each
+/// tensor is Rank 1 containing bucket boundaries for a single feature.
+///
+/// - Parameter quantile_stream_resource_handle: resource handle referring to a QuantileStreamResource.
+///
+/// - Attr num_features: inferred int; number of features to get bucket boundaries for.
+///
+/// - Output bucket_boundaries: float; List of Rank 1 Tensors each containing the bucket boundaries for a feature.
+@inlinable @inline(__always)
+public static func boostedTreesQuantileStreamResourceGetBucketBoundaries(
+    quantileStreamResourceHandle: ResourceHandle,
+    numFeatures: Int64
+) -> [Tensor<Float>] {
+  let nOutputs = Int(numFeatures)
+    let op = makeOp("BoostedTreesQuantileStreamResourceGetBucketBoundaries", nOutputs)
+    op.updateAttribute("num_features", numFeatures)
+    op.addInput(quantileStreamResourceHandle)
+    return op.execute(Int(numFeatures))
+}
+
+/// Creates a handle to a BoostedTreesQuantileStreamResource.
+@inlinable @inline(__always)
+public static func boostedTreesQuantileStreamResourceHandleOp(
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("BoostedTreesQuantileStreamResourceHandleOp", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Serializes the tree ensemble to a proto.
+///
+/// - Parameter tree_ensemble_handle: Handle to the tree ensemble.
+///
+/// - Outputs:
+///     - stamp_token: Stamp token of the tree ensemble resource.
+///     - tree_ensemble_serialized: Serialized proto of the ensemble.
+@inlinable @inline(__always)
+public static func boostedTreesSerializeEnsemble(
+    treeEnsembleHandle: ResourceHandle
+) -> (stampToken: Tensor<Int64>, treeEnsembleSerialized: StringTensor) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("BoostedTreesSerializeEnsemble", nOutputs)
+    op.addInput(treeEnsembleHandle)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Runs multiple additive regression ensemble predictors on input instances and
+///
+/// computes the update to cached logits. It is designed to be used during training.
+/// It traverses the trees starting from cached tree id and cached node id and
+/// calculates the updates to be pushed to the cache.
+///
+/// - Parameters:
+///     - cached_tree_ids: Rank 1 Tensor containing cached tree ids which is the starting
+///         tree of prediction.
+///     - cached_node_ids: Rank 1 Tensor containing cached node id which is the starting
+///         node of prediction.
+///     - bucketized_features: A list of rank 1 Tensors containing bucket id for each
+///         feature.
+///
+/// - Attrs:
+///     - num_bucketized_features: Inferred.
+///     - logits_dimension: scalar, dimension of the logits, to be used for partial logits
+///         shape.
+///
+/// - Outputs:
+///     - partial_logits: Rank 2 Tensor containing logits update (with respect to cached
+///         values stored) for each example.
+///     - tree_ids: Rank 1 Tensor containing new tree ids for each example.
+///     - node_ids: Rank 1 Tensor containing new node ids in the new tree_ids.
+@inlinable @inline(__always)
+public static func boostedTreesTrainingPredict(
+    treeEnsembleHandle: ResourceHandle,
+    cachedTreeIds: Tensor<Int32>,
+    cachedNodeIds: Tensor<Int32>,
+    bucketizedFeatures: [Tensor<Int32>],
+    logitsDimension: Int64
+) -> (partialLogits: Tensor<Float>, treeIds: Tensor<Int32>, nodeIds: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("BoostedTreesTrainingPredict", nOutputs)
+    op.updateAttribute("num_bucketized_features", bucketizedFeatures.count)
+    op.updateAttribute("logits_dimension", logitsDimension)
+    op.addInput(treeEnsembleHandle)
+    op.addInput(cachedTreeIds)
+    op.addInput(cachedNodeIds)
+    op.addInputList(bucketizedFeatures)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Updates the tree ensemble by either adding a layer to the last tree being grown
+///
+/// or by starting a new tree.
+///
+/// - Parameters:
+///     - tree_ensemble_handle: Handle to the ensemble variable.
+///     - feature_ids: Rank 1 tensor with ids for each feature. This is the real id of
+///         the feature that will be used in the split.
+///     - node_ids: List of rank 1 tensors representing the nodes for which this feature
+///         has a split.
+///     - gains: List of rank 1 tensors representing the gains for each of the feature's
+///         split.
+///     - thresholds: List of rank 1 tensors representing the thesholds for each of the
+///         feature's split.
+///     - left_node_contribs: List of rank 2 tensors with left leaf contribs for each of
+///         the feature's splits. Will be added to the previous node values to constitute
+///         the values of the left nodes.
+///     - right_node_contribs: List of rank 2 tensors with right leaf contribs for each
+///         of the feature's splits. Will be added to the previous node values to constitute
+///         the values of the right nodes.
+///     - max_depth: Max depth of the tree to build.
+///     - learning_rate: shrinkage const for each new tree.
+///
+/// - Attrs:
+///     - pruning_mode: 0-No pruning, 1-Pre-pruning, 2-Post-pruning.
+///     - num_features: Number of features that have best splits returned. INFERRED.
+@inlinable @inline(__always)
+public static func boostedTreesUpdateEnsemble(
+    treeEnsembleHandle: ResourceHandle,
+    featureIds: Tensor<Int32>,
+    nodeIds: [Tensor<Int32>],
+    gains: [Tensor<Float>],
+    thresholds: [Tensor<Int32>],
+    leftNodeContribs: [Tensor<Float>],
+    rightNodeContribs: [Tensor<Float>],
+    maxDepth: Tensor<Int32>,
+    learningRate: Tensor<Float>,
+    pruningMode: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("BoostedTreesUpdateEnsemble", nOutputs)
+    op.updateAttribute("pruning_mode", pruningMode)
+    op.updateAttribute("num_features", nodeIds.count)
+    op.addInput(treeEnsembleHandle)
+    op.addInput(featureIds)
+    op.addInputList(nodeIds)
+    op.addInputList(gains)
+    op.addInputList(thresholds)
+    op.addInputList(leftNodeContribs)
+    op.addInputList(rightNodeContribs)
+    op.addInput(maxDepth)
+    op.addInput(learningRate)
+    op.execute()
+}
+
+/// Return the shape of s0 op s1 with broadcast.
+///
+/// Given `s0` and `s1`, tensors that represent shapes, compute `r0`, the
+/// broadcasted shape. `s0`, `s1` and `r0` are all integer vectors.
+@inlinable @inline(__always)
+public static func broadcastArgs<T: BinaryInteger & TensorFlowScalar>(
+    s0: Tensor<T>,
+    s1: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BroadcastArgs", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(s0)
+    op.addInput(s1)
+    return op.execute(Int(1))
+}
+
+/// Return the reduction indices for computing gradients of s0 op s1 with broadcast.
+///
+/// This is typically used by gradient computations for a broadcasting operation.
+@inlinable @inline(__always)
+public static func broadcastGradientArgs<T: BinaryInteger & TensorFlowScalar>(
+    s0: Tensor<T>,
+    s1: Tensor<T>
+) -> (r0: Tensor<T>, r1: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("BroadcastGradientArgs", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(s0)
+    op.addInput(s1)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Broadcast an array for a compatible shape.
+///
+/// Broadcasting is the process of making arrays to have compatible shapes
+/// for arithmetic operations. Two shapes are compatible if for each
+/// dimension pair they are either equal or one of them is one. When trying
+/// to broadcast a Tensor to a shape, it starts with the trailing dimensions,
+/// and works its way forward.
+///
+/// For example,
+/// ```
+/// >>> x = tf.constant([1, 2, 3])
+/// >>> y = tf.broadcast_to(x, [3, 3])
+/// >>> sess.run(y)
+/// array([[1, 2, 3],
+///        [1, 2, 3],
+///        [1, 2, 3]], dtype=int32)
+/// ```
+/// In the above example, the input Tensor with the shape of `[1, 3]`
+/// is broadcasted to output Tensor with shape of `[3, 3]`.
+///
+/// - Parameters:
+///     - input: A Tensor to broadcast.
+///     - shape: An 1-D `int` Tensor. The shape of the desired output.
+///
+/// - Output output: A Tensor.
+@inlinable @inline(__always)
+public static func broadcastTo<
+    T: TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    shape: Tensor<Tidx>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("BroadcastTo", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Bucketizes 'input' based on 'boundaries'.
+///
+/// For example, if the inputs are
+///     boundaries = [0, 10, 100]
+///     input = [[-5, 10000]
+///              [150,   10]
+///              [5,    100]]
+///
+/// then the output will be
+///     output = [[0, 3]
+///               [3, 2]
+///               [1, 3]]
+///
+/// - Parameter input: Any shape of Tensor contains with int or float type.
+///
+/// - Attr boundaries: A sorted list of floats gives the boundary of the buckets.
+///
+/// - Output output: Same shape with 'input', each value of input replaced with bucket index.
+///
+///     @compatibility(numpy)
+///     Equivalent to np.digitize.
+///     @end_compatibility
+@inlinable @inline(__always)
+public static func bucketize<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    boundaries: [Double]
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("Bucketize", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("boundaries", boundaries)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Performs beam search decoding on the logits given in input.
+///
+/// A note about the attribute merge_repeated: For the beam search decoder,
+/// this means that if consecutive entries in a beam are the same, only
+/// the first of these is emitted.  That is, when the top path is "A B B B B",
+/// "A B" is returned if merge_repeated = True but "A B B B B" is
+/// returned if merge_repeated = False.
+///
+/// - Parameters:
+///     - inputs: 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
+///     - sequence_length: A vector containing sequence lengths, size `(batch)`.
+///
+/// - Attrs:
+///     - beam_width: A scalar >= 0 (beam search beam width).
+///     - top_paths: A scalar >= 0, <= beam_width (controls output size).
+///     - merge_repeated: If true, merge repeated classes in output.
+///
+/// - Outputs:
+///     - decoded_indices: A list (length: top_paths) of indices matrices.  Matrix j,
+///         size `(total_decoded_outputs[j] x 2)`, has indices of a
+///         `SparseTensor<int64, 2>`.  The rows store: [batch, time].
+///     - decoded_values: A list (length: top_paths) of values vectors.  Vector j,
+///         size `(length total_decoded_outputs[j])`, has the values of a
+///         `SparseTensor<int64, 2>`.  The vector stores the decoded classes for beam j.
+///     - decoded_shape: A list (length: top_paths) of shape vector.  Vector j,
+///         size `(2)`, stores the shape of the decoded `SparseTensor[j]`.
+///         Its values are: `[batch_size, max_decoded_length[j]]`.
+///     - log_probability: A matrix, shaped: `(batch_size x top_paths)`.  The
+///         sequence log-probabilities.
+@inlinable @inline(__always)
+public static func cTCBeamSearchDecoder(
+    inputs: Tensor<Float>,
+    sequenceLength: Tensor<Int32>,
+    beamWidth: Int64,
+    topPaths: Int64,
+    mergeRepeated: Bool = true
+) -> (decodedIndices: [Tensor<Int64>], decodedValues: [Tensor<Int64>], decodedShape: [Tensor<Int64>], logProbability: Tensor<Float>) {
+  let nOutputs = Int(topPaths) + Int(topPaths) + Int(topPaths) + Int(1)
+    let op = makeOp("CTCBeamSearchDecoder", nOutputs)
+    op.updateAttribute("beam_width", beamWidth)
+    op.updateAttribute("top_paths", topPaths)
+    op.updateAttribute("merge_repeated", mergeRepeated)
+    op.addInput(inputs)
+    op.addInput(sequenceLength)
+    return op.execute(Int(topPaths), Int(topPaths), Int(topPaths), Int(1))
+}
+
+/// Performs greedy decoding on the logits given in inputs.
+///
+/// A note about the attribute merge_repeated: if enabled, when
+/// consecutive logits' maximum indices are the same, only the first of
+/// these is emitted.  Labeling the blank '*', the sequence "A B B * B B"
+/// becomes "A B B" if merge_repeated = True and "A B B B B" if
+/// merge_repeated = False.
+///
+/// Regardless of the value of merge_repeated, if the maximum index of a given
+/// time and batch corresponds to the blank, index `(num_classes - 1)`, no new
+/// element is emitted.
+///
+/// - Parameters:
+///     - inputs: 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
+///     - sequence_length: A vector containing sequence lengths, size `(batch_size)`.
+///
+/// - Attr merge_repeated: If True, merge repeated classes in output.
+///
+/// - Outputs:
+///     - decoded_indices: Indices matrix, size `(total_decoded_outputs x 2)`,
+///         of a `SparseTensor<int64, 2>`.  The rows store: [batch, time].
+///     - decoded_values: Values vector, size: `(total_decoded_outputs)`,
+///         of a `SparseTensor<int64, 2>`.  The vector stores the decoded classes.
+///     - decoded_shape: Shape vector, size `(2)`, of the decoded SparseTensor.
+///         Values are: `[batch_size, max_decoded_length]`.
+///     - log_probability: Matrix, size `(batch_size x 1)`, containing sequence
+///         log-probabilities.
+@inlinable @inline(__always)
+public static func cTCGreedyDecoder(
+    inputs: Tensor<Float>,
+    sequenceLength: Tensor<Int32>,
+    mergeRepeated: Bool = false
+) -> (decodedIndices: Tensor<Int64>, decodedValues: Tensor<Int64>, decodedShape: Tensor<Int64>, logProbability: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("CTCGreedyDecoder", nOutputs)
+    op.updateAttribute("merge_repeated", mergeRepeated)
+    op.addInput(inputs)
+    op.addInput(sequenceLength)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Calculates the CTC Loss (log probability) for each batch entry.  Also calculates
+///
+/// the gradient.  This class performs the softmax operation for you, so inputs
+/// should be e.g. linear projections of outputs by an LSTM.
+///
+/// - Parameters:
+///     - inputs: 3-D, shape: `(max_time x batch_size x num_classes)`, the logits.
+///     - labels_indices: The indices of a `SparseTensor<int32, 2>`.
+///         `labels_indices(i, :) == [b, t]` means `labels_values(i)` stores the id for
+///         `(batch b, time t)`.
+///     - labels_values: The values (labels) associated with the given batch and time.
+///     - sequence_length: A vector containing sequence lengths (batch).
+///
+/// - Attrs:
+///     - preprocess_collapse_repeated: Scalar, if true then repeated labels are
+///         collapsed prior to the CTC calculation.
+///     - ctc_merge_repeated: Scalar.  If set to false, *during* CTC calculation
+///         repeated non-blank labels will not be merged and are interpreted as
+///         individual labels.  This is a simplified version of CTC.
+///     - ignore_longer_outputs_than_inputs: Scalar. If set to true, during CTC
+///         calculation, items that have longer output sequences than input sequences
+///         are skipped: they don't contribute to the loss term and have zero-gradient.
+///
+/// - Outputs:
+///     - loss: A vector (batch) containing log-probabilities.
+///     - gradient: The gradient of `loss`.  3-D, shape:
+///         `(max_time x batch_size x num_classes)`.
+@inlinable @inline(__always)
+public static func cTCLoss(
+    inputs: Tensor<Float>,
+    labelsIndices: Tensor<Int64>,
+    labelsValues: Tensor<Int32>,
+    sequenceLength: Tensor<Int32>,
+    preprocessCollapseRepeated: Bool = false,
+    ctcMergeRepeated: Bool = true,
+    ignoreLongerOutputsThanInputs: Bool = false
+) -> (loss: Tensor<Float>, gradient: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("CTCLoss", nOutputs)
+    op.updateAttribute("preprocess_collapse_repeated", preprocessCollapseRepeated)
+    op.updateAttribute("ctc_merge_repeated", ctcMergeRepeated)
+    op.updateAttribute("ignore_longer_outputs_than_inputs", ignoreLongerOutputsThanInputs)
+    op.addInput(inputs)
+    op.addInput(labelsIndices)
+    op.addInput(labelsValues)
+    op.addInput(sequenceLength)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Creates a dataset that caches elements from `input_dataset`.
+///
+/// A CacheDataset will iterate over the input_dataset, and store tensors. If the
+/// cache already exists, the cache will be used. If the cache is inappropriate
+/// (e.g. cannot be opened, contains tensors of the wrong shape / size), an error
+/// will the returned when used.
+///
+/// - Parameter filename: A path on the filesystem where we should cache the dataset. Note: this
+///     will be a directory.
+@inlinable @inline(__always)
+public static func cacheDataset(
+    inputDataset: VariantHandle,
+    filename: StringTensor,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("CacheDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(filename)
+    return op.execute(Int(1))
+}
+
+/// Cast x of type SrcT to y of DstT.
+@inlinable @inline(__always)
+public static func cast<
+    Srct: TensorFlowScalar,
+    Dstt: TensorFlowScalar
+>(
+    _ x: Tensor<Srct>,
+    truncate: Bool = false
+) -> Tensor<Dstt> {
+  let nOutputs = Int(1)
+    let op = makeOp("Cast", nOutputs)
+    op.updateAttribute("SrcT", Srct.tensorFlowDataType)
+    op.updateAttribute("DstT", Dstt.tensorFlowDataType)
+    op.updateAttribute("Truncate", truncate)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns element-wise smallest integer not less than x.
+@inlinable @inline(__always)
+public static func ceil<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Ceil", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// 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.
+///
+/// - Attr message: Prefix of the error message.
+@inlinable @inline(__always)
+public static func checkNumerics<T: FloatingPoint & TensorFlowScalar>(
+    _ tensor: Tensor<T>,
+    message: String
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("CheckNumerics", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("message", message)
+    op.addInput(tensor)
+    return op.execute(Int(1))
+}
+
+/// Computes the Cholesky decomposition of one or more square matrices.
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices.
+///
+/// The input has to be symmetric and positive definite. Only the lower-triangular
+/// part of the input will be used for this operation. The upper-triangular part
+/// will not be read.
+///
+/// The output is a tensor of the same shape as the input
+/// containing the Cholesky decompositions for all input submatrices `[..., :, :]`.
+///
+/// **Note**: The gradient computation on GPU is faster for large matrices but
+/// not for large batch dimensions when the submatrices are small. In this
+/// case it might be faster to use the CPU.
+///
+/// - Parameter input: Shape is `[..., M, M]`.
+///
+/// - Output output: Shape is `[..., M, M]`.
+@inlinable @inline(__always)
+public static func cholesky<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Cholesky", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Computes the reverse mode backpropagated gradient of the Cholesky algorithm.
+///
+/// For an explanation see "Differentiation of the Cholesky algorithm" by
+/// Iain Murray http://arxiv.org/abs/1602.07527.
+///
+/// - Parameters:
+///     - l: Output of batch Cholesky algorithm l = cholesky(A). Shape is `[..., M, M]`.
+///         Algorithm depends only on lower triangular part of the innermost matrices of
+///         this tensor.
+///     - grad: df/dl where f is some scalar function. Shape is `[..., M, M]`.
+///         Algorithm depends only on lower triangular part of the innermost matrices of
+///         this tensor.
+///
+/// - Output output: Symmetrized version of df/dA . Shape is `[..., M, M]`
+@inlinable @inline(__always)
+public static func choleskyGrad<T: FloatingPoint & TensorFlowScalar>(
+    l: Tensor<T>,
+    grad: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("CholeskyGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(l)
+    op.addInput(grad)
+    return op.execute(Int(1))
+}
+
+/// Clips tensor values to a specified min and max.
+///
+/// Given a tensor `t`, this operation returns a tensor of the same type and
+/// shape as `t` with its values clipped to `clip_value_min` and `clip_value_max`.
+/// Any values less than `clip_value_min` are set to `clip_value_min`. Any values
+/// greater than `clip_value_max` are set to `clip_value_max`.
+///
+/// - Parameters:
+///     - t: A `Tensor`.
+///     - clip_value_min: A 0-D (scalar) `Tensor`, or a `Tensor` with the same shape
+///         as `t`. The minimum value to clip by.
+///     - clip_value_max: A 0-D (scalar) `Tensor`, or a `Tensor` with the same shape
+///         as `t`. The maximum value to clip by.
+///
+/// - Output output: A clipped `Tensor` with the same shape as input 't'.
+@inlinable @inline(__always)
+public static func clipByValue<T: Numeric & TensorFlowScalar>(
+    t: Tensor<T>,
+    clipValueMin: Tensor<T>,
+    clipValueMax: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ClipByValue", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(t)
+    op.addInput(clipValueMin)
+    op.addInput(clipValueMax)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func closeSummaryWriter(
+    writer: ResourceHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("CloseSummaryWriter", nOutputs)
+    op.addInput(writer)
+    op.execute()
+}
+
+/// Receives a tensor value broadcast from another device.
+@inlinable @inline(__always)
+public static func collectiveBcastRecv<T: Numeric & TensorFlowScalar>(
+    groupSize: Int64,
+    groupKey: Int64,
+    instanceKey: Int64,
+    shape: TensorShape?
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("CollectiveBcastRecv", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("group_size", groupSize)
+    op.updateAttribute("group_key", groupKey)
+    op.updateAttribute("instance_key", instanceKey)
+    op.updateAttribute("shape", shape)
+    return op.execute(Int(1))
+}
+
+/// Broadcasts a tensor value to one or more other devices.
+@inlinable @inline(__always)
+public static func collectiveBcastSend<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    groupSize: Int64,
+    groupKey: Int64,
+    instanceKey: Int64,
+    shape: TensorShape?
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("CollectiveBcastSend", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("group_size", groupSize)
+    op.updateAttribute("group_key", groupKey)
+    op.updateAttribute("instance_key", instanceKey)
+    op.updateAttribute("shape", shape)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Mutually accumulates multiple tensors of identical type and shape.
+@inlinable @inline(__always)
+public static func collectiveGather<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    groupSize: Int64,
+    groupKey: Int64,
+    instanceKey: Int64,
+    shape: TensorShape?
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("CollectiveGather", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("group_size", groupSize)
+    op.updateAttribute("group_key", groupKey)
+    op.updateAttribute("instance_key", instanceKey)
+    op.updateAttribute("shape", shape)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// An Op to permute tensors across replicated TPU instances.
+///
+/// Each instance supplies its own input.
+///
+/// For example, suppose there are 4 TPU instances: `[A, B, C, D]`. Passing
+/// source_target_pairs=`[[0,1],[1,2],[2,3],[3,0]]` gets the outputs:
+/// `[D, A, B, C]`.
+///
+/// - Parameters:
+///     - input: The local input to be permuted. Currently only supports float and
+///         bfloat16.
+///     - source_target_pairs: A tensor with shape [num_pairs, 2].
+///
+/// - Attr T: The type of elements to be exchanged.
+///
+/// - Output output: The permuted input.
+@inlinable @inline(__always)
+public static func collectivePermute<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    sourceTargetPairs: Tensor<Int32>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("CollectivePermute", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(sourceTargetPairs)
+    return op.execute(Int(1))
+}
+
+/// Mutually reduces multiple tensors of identical type and shape.
+@inlinable @inline(__always)
+public static func collectiveReduce<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    groupSize: Int64,
+    groupKey: Int64,
+    instanceKey: Int64,
+    mergeOp: MergeOp,
+    finalOp: FinalOp,
+    subdivOffsets: [Int32],
+    waitFor: [Int32]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("CollectiveReduce", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("group_size", groupSize)
+    op.updateAttribute("group_key", groupKey)
+    op.updateAttribute("instance_key", instanceKey)
+    op.updateAttribute("merge_op", mergeOp.cName)
+    op.updateAttribute("final_op", finalOp.cName)
+    op.updateAttribute("subdiv_offsets", subdivOffsets)
+    op.updateAttribute("wait_for", waitFor)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Greedily selects a subset of bounding boxes in descending order of score,
+///
+/// This operation performs non_max_suppression on the inputs per batch, across
+/// all classes.
+/// Prunes away boxes that have high intersection-over-union (IOU) overlap
+/// with previously selected boxes.  Bounding boxes are supplied as
+/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+/// diagonal pair of box corners and the coordinates can be provided as normalized
+/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+/// is agnostic to where the origin is in the coordinate system. Also note that
+/// this algorithm is invariant to orthogonal transformations and translations
+/// of the coordinate system; thus translating or reflections of the coordinate
+/// system result in the same boxes being selected by the algorithm.
+/// The output of this operation is the final boxes, scores and classes tensor
+/// returned after performing non_max_suppression.
+///
+/// - Parameters:
+///     - boxes: A 4-D float tensor of shape `[batch_size, num_boxes, q, 4]`. If `q` is 1 then 
+///         same boxes are used for all classes otherwise, if `q` is equal to number of 
+///         classes, class-specific boxes are used.
+///     - scores: A 3-D float tensor of shape `[batch_size, num_boxes, num_classes]`
+///         representing a single score corresponding to each box (each row of boxes).
+///     - max_output_size_per_class: A scalar integer tensor representing the maximum number of 
+///         boxes to be selected by non max suppression per class
+///     - max_total_size: A scalar representing maximum number of boxes retained over all classes.
+///     - iou_threshold: A 0-D float tensor representing the threshold for deciding whether
+///         boxes overlap too much with respect to IOU.
+///     - score_threshold: A 0-D float tensor representing the threshold for deciding when to remove
+///         boxes based on score.
+///
+/// - Attrs:
+///     - pad_per_class: If false, the output nmsed boxes, scores and classes
+///         are padded/clipped to `max_total_size`. If true, the
+///         output nmsed boxes, scores and classes are padded to be of length
+///         `max_size_per_class`*`num_classes`, unless it exceeds `max_total_size` in
+///         which case it is clipped to `max_total_size`. Defaults to false.
+///     - clip_boxes: If true, assume the box coordinates are between [0, 1] and clip the output boxes
+///         if they fall beyond [0, 1]. If false, do not do clipping and output the box
+///         coordinates as it is.
+///
+/// - Outputs:
+///     - nmsed_boxes: A [batch_size, max_detections, 4] float32 tensor 
+///         containing the non-max suppressed boxes.
+///     - nmsed_scores: A [batch_size, max_detections] float32 tensor 
+///         containing the scores for the boxes.
+///     - nmsed_classes: A [batch_size, max_detections] float32 tensor 
+///         containing the classes for the boxes.
+///     - valid_detections: A [batch_size] int32 tensor indicating the number of
+///         valid detections per batch item. Only the top num_detections[i] entries in
+///         nms_boxes[i], nms_scores[i] and nms_class[i] are valid. The rest of the
+///         entries are zero paddings.
+@inlinable @inline(__always)
+public static func combinedNonMaxSuppression(
+    boxes: Tensor<Float>,
+    scores: Tensor<Float>,
+    maxOutputSizePerClass: Tensor<Int32>,
+    maxTotalSize: Tensor<Int32>,
+    iouThreshold: Tensor<Float>,
+    scoreThreshold: Tensor<Float>,
+    padPerClass: Bool = false,
+    clipBoxes: Bool = true
+) -> (nmsedBoxes: Tensor<Float>, nmsedScores: Tensor<Float>, nmsedClasses: Tensor<Float>, validDetections: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("CombinedNonMaxSuppression", nOutputs)
+    op.updateAttribute("pad_per_class", padPerClass)
+    op.updateAttribute("clip_boxes", clipBoxes)
+    op.addInput(boxes)
+    op.addInput(scores)
+    op.addInput(maxOutputSizePerClass)
+    op.addInput(maxTotalSize)
+    op.addInput(iouThreshold)
+    op.addInput(scoreThreshold)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Compare values of `input` to `threshold` and pack resulting bits into a `uint8`.
+///
+/// Each comparison returns a boolean `true` (if `input_value > threshold`)
+/// or and `false` otherwise.
+///
+/// This operation is useful for Locality-Sensitive-Hashing (LSH) and other
+/// algorithms that use hashing approximations of cosine and `L2` distances;
+/// codes can be generated from an input via:
+///
+/// ```python
+/// codebook_size = 50
+/// codebook_bits = codebook_size * 32
+/// codebook = tf.get_variable('codebook', [x.shape[-1].value, codebook_bits],
+///                            dtype=x.dtype,
+///                            initializer=tf.orthogonal_initializer())
+/// codes = compare_and_threshold(tf.matmul(x, codebook), threshold=0.)
+/// codes = tf.bitcast(codes, tf.int32)  # go from uint8 to int32
+/// # now codes has shape x.shape[:-1] + [codebook_size]
+/// ```
+///
+/// **NOTE**: Currently, the innermost dimension of the tensor must be divisible
+/// by 8.
+///
+/// Given an `input` shaped `[s0, s1, ..., s_n]`, the output is
+/// a `uint8` tensor shaped `[s0, s1, ..., s_n / 8]`.
+///
+/// - Parameters:
+///     - input: Values to compare against `threshold` and bitpack.
+///     - threshold: Threshold to compare against.
+///
+/// - Attr T: The type of the input and threshold.
+///
+/// - Output output: The bitpacked comparisons.
+@inlinable @inline(__always)
+public static func compareAndBitpack<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    threshold: Tensor<T>
+) -> Tensor<UInt8> {
+  let nOutputs = Int(1)
+    let op = makeOp("CompareAndBitpack", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(threshold)
+    return op.execute(Int(1))
+}
+
+/// Converts two real numbers to a complex number.
+///
+/// Given a tensor `real` representing the real part of a complex number, and a
+/// tensor `imag` representing the imaginary part of a complex number, this
+/// operation returns complex numbers elementwise of the form \\(a + bj\\), where
+/// *a* represents the `real` part and *b* represents the `imag` part.
+///
+/// The input tensors `real` and `imag` must have the same shape.
+///
+/// For example:
+///
+/// ```
+/// # tensor 'real' is [2.25, 3.25]
+/// # tensor `imag` is [4.75, 5.75]
+/// tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]]
+/// ```
+@inlinable @inline(__always)
+public static func complex<
+    T: FloatingPoint & TensorFlowScalar,
+    Tout: TensorFlowScalar
+>(
+    real: Tensor<T>,
+    imag: Tensor<T>
+) -> Tensor<Tout> {
+  let nOutputs = Int(1)
+    let op = makeOp("Complex", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tout", Tout.tensorFlowDataType)
+    op.addInput(real)
+    op.addInput(imag)
+    return op.execute(Int(1))
+}
+
+/// Computes the complex absolute value of a tensor.
+///
+/// Given a tensor `x` of complex numbers, this operation returns a tensor of type
+/// `float` or `double` that is the absolute value of each element in `x`. All
+/// elements in `x` must be complex numbers of the form \\(a + bj\\). The absolute
+/// value is computed as \\( \sqrt{a^2 + b^2}\\).
+@inlinable @inline(__always)
+public static func complexAbs<
+    T: TensorFlowScalar,
+    Tout: FloatingPoint & TensorFlowScalar
+>(
+    _ x: Tensor<T>
+) -> Tensor<Tout> {
+  let nOutputs = Int(1)
+    let op = makeOp("ComplexAbs", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tout", Tout.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func complexStruct<TC: TensorGroup>(
+    nA: Int64,
+    nB: Int64
+) -> (a: [Tensor<Int32>], b: [Tensor<Int64>], c: TC) {
+  let nOutputs = Int(nA) + Int(nB) + Int(TC._typeList.count)
+    let op = makeOp("ComplexStruct", nOutputs)
+    op.updateAttribute("n_a", nA)
+    op.updateAttribute("n_b", nB)
+    op.updateAttribute("t_c", TC._typeList)
+    return op.execute(Int(nA), Int(nB), Int(TC._typeList.count))
+}
+
+/// Computes the ids of the positions in sampled_candidates that match true_labels.
+///
+/// When doing log-odds NCE, the result of this op should be passed through a
+/// SparseToDense op, then added to the logits of the sampled candidates. This has
+/// the effect of 'removing' the sampled labels that match the true labels by
+/// making the classifier sure that they are sampled labels.
+///
+/// - Parameters:
+///     - true_classes: The true_classes output of UnpackSparseLabels.
+///     - sampled_candidates: The sampled_candidates output of CandidateSampler.
+///
+/// - Attrs:
+///     - num_true: Number of true labels per context.
+///     - seed: If either seed or seed2 are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///     - indices: A vector of indices corresponding to rows of true_candidates.
+///     - ids: A vector of IDs of positions in sampled_candidates that match a true_label
+///         for the row with the corresponding index in indices.
+///     - weights: A vector of the same length as indices and ids, in which each element
+///         is -FLOAT_MAX.
+@inlinable @inline(__always)
+public static func computeAccidentalHits(
+    trueClasses: Tensor<Int64>,
+    sampledCandidates: Tensor<Int64>,
+    numTrue: Int64,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> (indices: Tensor<Int32>, ids: Tensor<Int64>, weights: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("ComputeAccidentalHits", nOutputs)
+    op.updateAttribute("num_true", numTrue)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(trueClasses)
+    op.addInput(sampledCandidates)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Concatenates tensors along one dimension.
+///
+/// - Parameters:
+///     - concat_dim: 0-D.  The dimension along which to concatenate.  Must be in the
+///         range [0, rank(values)).
+///     - values: The `N` Tensors to concatenate. Their ranks and types must match,
+///         and their sizes must match in all dimensions except `concat_dim`.
+///
+/// - Output output: A `Tensor` with the concatenation of values stacked along the
+///     `concat_dim` dimension.  This tensor's shape matches that of `values` except
+///     in `concat_dim` where it has the sum of the sizes.
+@inlinable @inline(__always)
+public static func concat<T: TensorFlowScalar>(
+    concatDim: Tensor<Int32>,
+    _ values: [Tensor<T>]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Concat", nOutputs)
+    op.updateAttribute("N", values.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(concatDim)
+    op.addInputList(values)
+    return op.execute(Int(1))
+}
+
+/// Computes offsets of concat inputs within its output.
+///
+/// For example:
+///
+/// ```
+/// # 'x' is [2, 2, 7]
+/// # 'y' is [2, 3, 7]
+/// # 'z' is [2, 5, 7]
+/// concat_offset(2, [x, y, z]) => [0, 0, 0], [0, 2, 0], [0, 5, 0]
+/// ```
+///
+/// This is typically used by gradient computations for a concat operation.
+///
+/// - Parameters:
+///     - concat_dim: The dimension along which to concatenate.
+///     - shape: The `N` int32 vectors representing shape of tensors being concatenated.
+///
+/// - Output offset: The `N` int32 vectors representing the starting offset
+///     of input tensors within the concatenated output.
+@inlinable @inline(__always)
+public static func concatOffset(
+    concatDim: Tensor<Int32>,
+    shape: [Tensor<Int32>]
+) -> [Tensor<Int32>] {
+  let nOutputs = Int(shape.count)
+    let op = makeOp("ConcatOffset", nOutputs)
+    op.updateAttribute("N", shape.count)
+    op.addInput(concatDim)
+    op.addInputList(shape)
+    return op.execute(Int(shape.count))
+}
+
+/// Concatenates tensors along one dimension.
+///
+/// - Parameters:
+///     - values: List of `N` Tensors to concatenate. Their ranks and types must match,
+///         and their sizes must match in all dimensions except `concat_dim`.
+///     - axis: 0-D.  The dimension along which to concatenate.  Must be in the
+///         range [-rank(values), rank(values)).
+///
+/// - Output output: A `Tensor` with the concatenation of values stacked along the
+///     `concat_dim` dimension.  This tensor's shape matches that of `values` except
+///     in `concat_dim` where it has the sum of the sizes.
+@inlinable @inline(__always)
+public static func concatV2<
+    T: TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    _ values: [Tensor<T>],
+    axis: Tensor<Tidx>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ConcatV2", nOutputs)
+    op.updateAttribute("N", values.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInputList(values)
+    op.addInput(axis)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that concatenates `input_dataset` with `another_dataset`.
+@inlinable @inline(__always)
+public static func concatenateDataset(
+    inputDataset: VariantHandle,
+    anotherDataset: VariantHandle,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ConcatenateDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(anotherDataset)
+    return op.execute(Int(1))
+}
+
+/// Sets up the centralized structures for a distributed TPU system.
+///
+/// - Attrs:
+///     - embedding_config: Reserved. Do not use.
+///     - tpu_embedding_config: Serialized tensorflow.tpu.TPUEmbeddingConfiguration that
+///         describes the embedding lookups of the program.
+///     - is_global_init: Reserved. Do not use.
+///
+/// - Output topology: A serialized tensorflow.tpu.TopologyProto that describes the TPU
+///     topology.
+@inlinable @inline(__always)
+public static func configureDistributedTPU(
+    embeddingConfig: String,
+    tpuEmbeddingConfig: String,
+    isGlobalInit: Bool = false
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("ConfigureDistributedTPU", nOutputs)
+    op.updateAttribute("embedding_config", embeddingConfig)
+    op.updateAttribute("tpu_embedding_config", tpuEmbeddingConfig)
+    op.updateAttribute("is_global_init", isGlobalInit)
+    return op.execute(Int(1))
+}
+
+/// Returns the complex conjugate of a complex number.
+///
+/// Given a tensor `input` of complex numbers, this operation returns a tensor of
+/// complex numbers that are the complex conjugate of each element in `input`. The
+/// complex numbers in `input` must be of the form \\(a + bj\\), where *a* is the
+/// real part and *b* is the imaginary part.
+///
+/// The complex conjugate returned by this operation is of the form \\(a - bj\\).
+///
+/// For example:
+///
+/// ```
+/// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
+/// tf.conj(input) ==> [-2.25 - 4.75j, 3.25 - 5.75j]
+/// ```
+@inlinable @inline(__always)
+public static func conj<T: TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Conj", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Shuffle dimensions of x according to a permutation and conjugate the result.
+///
+/// The output `y` has the same rank as `x`. The shapes of `x` and `y` satisfy:
+///   `y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]`
+///   `y[i,j,k,...,s,t,u] == conj(x[perm[i], perm[j], perm[k],...,perm[s], perm[t], perm[u]])`
+@inlinable @inline(__always)
+public static func conjugateTranspose<
+    T: TensorFlowScalar,
+    Tperm: BinaryInteger & TensorFlowScalar
+>(
+    _ x: Tensor<T>,
+    perm: Tensor<Tperm>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ConjugateTranspose", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tperm", Tperm.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(perm)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func constructionFails(
+) {
+  let nOutputs = 0
+    let op = makeOp("ConstructionFails", nOutputs)
+    
+    op.execute()
+}
+
+/// This op consumes a lock created by `MutexLock`.
+///
+/// This op exists to consume a tensor created by `MutexLock` (other than
+/// direct control dependencies).  It should be the only that consumes the tensor,
+/// and will raise an error if it is not.  Its only purpose is to keep the
+/// mutex lock tensor alive until it is consumed by this op.
+///
+/// **NOTE**: This operation must run on the same device as its input.  This may
+/// be enforced via the `colocate_with` mechanism.
+///
+/// - Parameter mutex_lock: A tensor returned by `MutexLock`.
+@inlinable @inline(__always)
+public static func consumeMutexLock(
+    mutexLock: VariantHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("ConsumeMutexLock", nOutputs)
+    op.addInput(mutexLock)
+    op.execute()
+}
+
+/// Does nothing. Serves as a control trigger for scheduling.
+///
+/// Only useful as a placeholder for control edges.
+@inlinable @inline(__always)
+public static func controlTrigger(
+) {
+  let nOutputs = 0
+    let op = makeOp("ControlTrigger", nOutputs)
+    
+    op.execute()
+}
+
+/// Computes a 2-D convolution given 4-D `input` and `filter` tensors.
+///
+/// Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
+/// and a filter / kernel tensor of shape
+/// `[filter_height, filter_width, in_channels, out_channels]`, this op
+/// performs the following:
+///
+/// 1. Flattens the filter to a 2-D matrix with shape
+///    `[filter_height * filter_width * in_channels, output_channels]`.
+/// 2. Extracts image patches from the input tensor to form a *virtual*
+///    tensor of shape `[batch, out_height, out_width,
+///    filter_height * filter_width * in_channels]`.
+/// 3. For each patch, right-multiplies the filter matrix and the image patch
+///    vector.
+///
+/// In detail, with the default NHWC format,
+///
+///     output[b, i, j, k] =
+///         sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] *
+///                         filter[di, dj, q, k]
+///
+/// Must have `strides[0] = strides[3] = 1`.  For the most common case of the same
+/// horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
+///
+/// - Parameters:
+///     - input: A 4-D tensor. The dimension order is interpreted according to the value
+///         of `data_format`, see below for details.
+///     - filter: A 4-D tensor of shape
+///         `[filter_height, filter_width, in_channels, out_channels]`
+///
+/// - Attrs:
+///     - strides: 1-D tensor of length 4.  The stride of the sliding window for each
+///         dimension of `input`. The dimension order is determined by the value of
+///         `data_format`, see below for details.
+///     - padding: The type of padding algorithm to use.
+///     - explicit_paddings: If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
+///         dimension, the amount of padding inserted before and after the dimension is
+///         `explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
+///         `padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, height, width, channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, channels, height, width].
+///     - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///         `input`. If set to k > 1, there will be k-1 skipped cells between each
+///         filter element on that dimension. The dimension order is determined by the
+///         value of `data_format`, see above for details. Dilations in the batch and
+///         depth dimensions must be 1.
+///
+/// - Output output: A 4-D tensor. The dimension order is determined by the value of
+///     `data_format`, see below for details.
+@inlinable @inline(__always)
+public static func conv2D<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    filter: Tensor<T>,
+    strides: [Int32],
+    useCudnnOnGpu: Bool = true,
+    padding: Padding2,
+    explicitPaddings: [Int32],
+    dataFormat: DataFormat = .nhwc,
+    dilations: [Int32] = [1, 1, 1, 1]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Conv2D", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("use_cudnn_on_gpu", useCudnnOnGpu)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("explicit_paddings", explicitPaddings)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filter)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradients of convolution with respect to the filter.
+///
+/// - Parameters:
+///     - input: 4-D with shape `[batch, in_height, in_width, in_channels]`.
+///     - filter_sizes: An integer vector representing the tensor shape of `filter`,
+///         where `filter` is a 4-D
+///         `[filter_height, filter_width, in_channels, out_channels]` tensor.
+///     - out_backprop: 4-D with shape `[batch, out_height, out_width, out_channels]`.
+///         Gradients w.r.t. the output of the convolution.
+///
+/// - Attrs:
+///     - strides: The stride of the sliding window for each dimension of the input
+///         of the convolution. Must be in the same order as the dimension specified with
+///         format.
+///     - padding: The type of padding algorithm to use.
+///     - explicit_paddings: If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
+///         dimension, the amount of padding inserted before and after the dimension is
+///         `explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
+///         `padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, in_channels, in_height, in_width].
+///     - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///         `input`. If set to k > 1, there will be k-1 skipped cells between each filter
+///         element on that dimension. The dimension order is determined by the value of
+///         `data_format`, see above for details. Dilations in the batch and depth
+///         dimensions must be 1.
+///
+/// - Output output: 4-D with shape
+///     `[filter_height, filter_width, in_channels, out_channels]`.  Gradient w.r.t.
+///     the `filter` input of the convolution.
+@inlinable @inline(__always)
+public static func conv2DBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    filterSizes: Tensor<Int32>,
+    outBackprop: Tensor<T>,
+    strides: [Int32],
+    useCudnnOnGpu: Bool = true,
+    padding: Padding2,
+    explicitPaddings: [Int32],
+    dataFormat: DataFormat = .nhwc,
+    dilations: [Int32] = [1, 1, 1, 1]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Conv2DBackpropFilter", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("use_cudnn_on_gpu", useCudnnOnGpu)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("explicit_paddings", explicitPaddings)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filterSizes)
+    op.addInput(outBackprop)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradients of convolution with respect to the input.
+///
+/// - Parameters:
+///     - input_sizes: An integer vector representing the shape of `input`,
+///         where `input` is a 4-D `[batch, height, width, channels]` tensor.
+///     - filter: 4-D with shape
+///         `[filter_height, filter_width, in_channels, out_channels]`.
+///     - out_backprop: 4-D with shape `[batch, out_height, out_width, out_channels]`.
+///         Gradients w.r.t. the output of the convolution.
+///
+/// - Attrs:
+///     - strides: The stride of the sliding window for each dimension of the input
+///         of the convolution. Must be in the same order as the dimension specified with
+///         format.
+///     - padding: The type of padding algorithm to use.
+///     - explicit_paddings: If `padding` is `"EXPLICIT"`, the list of explicit padding amounts. For the ith
+///         dimension, the amount of padding inserted before and after the dimension is
+///         `explicit_paddings[2 * i]` and `explicit_paddings[2 * i + 1]`, respectively. If
+///         `padding` is not `"EXPLICIT"`, `explicit_paddings` must be empty.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, in_channels, in_height, in_width].
+///     - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///         `input`. If set to k > 1, there will be k-1 skipped cells between each filter
+///         element on that dimension. The dimension order is determined by the value of
+///         `data_format`, see above for details. Dilations in the batch and depth
+///         dimensions must be 1.
+///
+/// - Output output: 4-D with shape `[batch, in_height, in_width, in_channels]`.  Gradient
+///     w.r.t. the input of the convolution.
+@inlinable @inline(__always)
+public static func conv2DBackpropInput<T: FloatingPoint & TensorFlowScalar>(
+    inputSizes: Tensor<Int32>,
+    filter: Tensor<T>,
+    outBackprop: Tensor<T>,
+    strides: [Int32],
+    useCudnnOnGpu: Bool = true,
+    padding: Padding2,
+    explicitPaddings: [Int32],
+    dataFormat: DataFormat = .nhwc,
+    dilations: [Int32] = [1, 1, 1, 1]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Conv2DBackpropInput", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("use_cudnn_on_gpu", useCudnnOnGpu)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("explicit_paddings", explicitPaddings)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(inputSizes)
+    op.addInput(filter)
+    op.addInput(outBackprop)
+    return op.execute(Int(1))
+}
+
+/// Computes a 3-D convolution given 5-D `input` and `filter` tensors.
+///
+/// In signal processing, cross-correlation is a measure of similarity of
+/// two waveforms as a function of a time-lag applied to one of them. This
+/// is also known as a sliding dot product or sliding inner-product.
+///
+/// Our Conv3D implements a form of cross-correlation.
+///
+/// - Parameters:
+///     - input: Shape `[batch, in_depth, in_height, in_width, in_channels]`.
+///     - filter: Shape `[filter_depth, filter_height, filter_width, in_channels,
+///         out_channels]`. `in_channels` must match between `input` and `filter`.
+///
+/// - Attrs:
+///     - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///         dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: The data format of the input and output data. With the
+///         default format "NDHWC", the data is stored in the order of:
+///             [batch, in_depth, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCDHW", the data storage order is:
+///             [batch, in_channels, in_depth, in_height, in_width].
+///     - dilations: 1-D tensor of length 5.  The dilation factor for each dimension of
+///         `input`. If set to k > 1, there will be k-1 skipped cells between each
+///         filter element on that dimension. The dimension order is determined by the
+///         value of `data_format`, see above for details. Dilations in the batch and
+///         depth dimensions must be 1.
+@inlinable @inline(__always)
+public static func conv3D<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    filter: Tensor<T>,
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat1 = .ndhwc,
+    dilations: [Int32] = [1, 1, 1, 1, 1]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Conv3D", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filter)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradients of 3-D convolution with respect to the filter.
+///
+/// - Parameters:
+///     - input: Shape `[batch, depth, rows, cols, in_channels]`.
+///     - filter: Shape `[depth, rows, cols, in_channels, out_channels]`.
+///         `in_channels` must match between `input` and `filter`.
+///     - out_backprop: Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
+///         out_channels]`.
+///
+/// - Attrs:
+///     - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///         dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///     - padding: The type of padding algorithm to use.
+@inlinable @inline(__always)
+public static func conv3DBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    filter: Tensor<T>,
+    outBackprop: Tensor<T>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1, 1]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Conv3DBackpropFilter", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(outBackprop)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradients of 3-D convolution with respect to the filter.
+///
+/// - Parameters:
+///     - input: Shape `[batch, depth, rows, cols, in_channels]`.
+///     - filter_sizes: An integer vector representing the tensor shape of `filter`,
+///         where `filter` is a 5-D
+///         `[filter_depth, filter_height, filter_width, in_channels, out_channels]`
+///         tensor.
+///     - out_backprop: Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
+///         out_channels]`.
+///
+/// - Attrs:
+///     - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///         dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: The data format of the input and output data. With the
+///         default format "NDHWC", the data is stored in the order of:
+///             [batch, in_depth, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCDHW", the data storage order is:
+///             [batch, in_channels, in_depth, in_height, in_width].
+///     - dilations: 1-D tensor of length 5.  The dilation factor for each dimension of
+///         `input`. If set to k > 1, there will be k-1 skipped cells between each
+///         filter element on that dimension. The dimension order is determined by the
+///         value of `data_format`, see above for details. Dilations in the batch and
+///         depth dimensions must be 1.
+@inlinable @inline(__always)
+public static func conv3DBackpropFilterV2<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    filterSizes: Tensor<Int32>,
+    outBackprop: Tensor<T>,
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat1 = .ndhwc,
+    dilations: [Int32] = [1, 1, 1, 1, 1]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Conv3DBackpropFilterV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filterSizes)
+    op.addInput(outBackprop)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradients of 3-D convolution with respect to the input.
+///
+/// - Parameters:
+///     - input: Shape `[batch, depth, rows, cols, in_channels]`.
+///     - filter: Shape `[depth, rows, cols, in_channels, out_channels]`.
+///         `in_channels` must match between `input` and `filter`.
+///     - out_backprop: Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
+///         out_channels]`.
+///
+/// - Attrs:
+///     - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///         dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///     - padding: The type of padding algorithm to use.
+@inlinable @inline(__always)
+public static func conv3DBackpropInput<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    filter: Tensor<T>,
+    outBackprop: Tensor<T>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1, 1]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Conv3DBackpropInput", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(outBackprop)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradients of 3-D convolution with respect to the input.
+///
+/// - Parameters:
+///     - input_sizes: An integer vector representing the tensor shape of `input`,
+///         where `input` is a 5-D
+///         `[batch, depth, rows, cols, in_channels]` tensor.
+///     - filter: Shape `[depth, rows, cols, in_channels, out_channels]`.
+///         `in_channels` must match between `input` and `filter`.
+///     - out_backprop: Backprop signal of shape `[batch, out_depth, out_rows, out_cols,
+///         out_channels]`.
+///
+/// - Attrs:
+///     - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///         dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: The data format of the input and output data. With the
+///         default format "NDHWC", the data is stored in the order of:
+///             [batch, in_depth, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCDHW", the data storage order is:
+///             [batch, in_channels, in_depth, in_height, in_width].
+///     - dilations: 1-D tensor of length 5.  The dilation factor for each dimension of
+///         `input`. If set to k > 1, there will be k-1 skipped cells between each
+///         filter element on that dimension. The dimension order is determined by the
+///         value of `data_format`, see above for details. Dilations in the batch and
+///         depth dimensions must be 1.
+@inlinable @inline(__always)
+public static func conv3DBackpropInputV2<
+    T: FloatingPoint & TensorFlowScalar,
+    Tshape: BinaryInteger & TensorFlowScalar
+>(
+    inputSizes: Tensor<Tshape>,
+    filter: Tensor<T>,
+    outBackprop: Tensor<T>,
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat1 = .ndhwc,
+    dilations: [Int32] = [1, 1, 1, 1, 1]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Conv3DBackpropInputV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("dilations", dilations)
+    op.updateAttribute("Tshape", Tshape.tensorFlowDataType)
+    op.addInput(inputSizes)
+    op.addInput(filter)
+    op.addInput(outBackprop)
+    return op.execute(Int(1))
+}
+
+/// Copy Op.
+///
+/// Performs CPU-to-CPU or GPU-to-GPU deep-copying of tensor, depending on the
+/// device on which the tensor is allocated.
+/// N.B.: If the all downstream attached debug ops are disabled given the current
+/// gRPC gating status, the output will simply forward the input tensor without
+/// deep-copying. See the documentation of Debug* ops for more details.
+///
+/// Unlike the CopyHost Op, this op does not have HostMemory constraint on its
+/// input or output.
+///
+/// - Parameter input: Input tensor.
+///
+/// - Attrs:
+///     - tensor_name: The name of the input tensor.
+///     - debug_ops_spec: A list of debug op spec (op, url, gated_grpc) for attached debug
+///         ops. Each element of the list has the format
+///         <debug_op>;<grpc_url>;<gated_grpc>, wherein gated_grpc is boolean represented
+///         as 0/1. E.g., "DebugIdentity;grpc://foo:3333;1",
+///         "DebugIdentity;file:///tmp/tfdbg_1;0".
+///
+/// - Output output: Output tensor, deep-copied from input.
+@inlinable @inline(__always)
+public static func copy<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    tensorName: String,
+    debugOpsSpec: [String]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Copy", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("tensor_name", tensorName)
+    op.updateAttribute("debug_ops_spec", debugOpsSpec)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Copy Host Op.
+///
+/// Performs CPU-to-CPU deep-copying of tensor.
+/// N.B.: If the all downstream attached debug ops are disabled given the current
+/// gRPC gating status, the output will simply forward the input tensor without
+/// deep-copying. See the documentation of Debug* ops for more details.
+///
+/// Unlike the Copy Op, this op has HostMemory constraint on its input or output.
+///
+/// - Parameter input: Input tensor.
+///
+/// - Attrs:
+///     - tensor_name: The name of the input tensor.
+///     - debug_ops_spec: A list of debug op spec (op, url, gated_grpc) for attached debug
+///         ops. Each element of the list has the format
+///         <debug_op>;<grpc_url>;<gated_grpc>, wherein gated_grpc is boolean represented
+///         as 0/1. E.g., "DebugIdentity;grpc://foo:3333;1",
+///         "DebugIdentity;file:///tmp/tfdbg_1;0".
+///
+/// - Output output: Output tensor, deep-copied from input.
+@inlinable @inline(__always)
+public static func copyHost<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    tensorName: String,
+    debugOpsSpec: [String]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("CopyHost", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("tensor_name", tensorName)
+    op.updateAttribute("debug_ops_spec", debugOpsSpec)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func copyOp<T: TensorFlowScalar>(
+    _ a: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("CopyOp", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    return op.execute(Int(1))
+}
+
+/// Computes cos of x element-wise.
+@inlinable @inline(__always)
+public static func cos<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Cos", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes hyperbolic cosine of x element-wise.
+@inlinable @inline(__always)
+public static func cosh<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Cosh", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func createSummaryDbWriter(
+    writer: ResourceHandle,
+    dbUri: StringTensor,
+    experimentName: StringTensor,
+    runName: StringTensor,
+    userName: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("CreateSummaryDbWriter", nOutputs)
+    op.addInput(writer)
+    op.addInput(dbUri)
+    op.addInput(experimentName)
+    op.addInput(runName)
+    op.addInput(userName)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func createSummaryFileWriter(
+    writer: ResourceHandle,
+    logdir: StringTensor,
+    maxQueue: Tensor<Int32>,
+    flushMillis: Tensor<Int32>,
+    filenameSuffix: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("CreateSummaryFileWriter", nOutputs)
+    op.addInput(writer)
+    op.addInput(logdir)
+    op.addInput(maxQueue)
+    op.addInput(flushMillis)
+    op.addInput(filenameSuffix)
+    op.execute()
+}
+
+/// Extracts crops from the input image tensor and resizes them.
+///
+/// Extracts crops from the input image tensor and resizes them using bilinear
+/// sampling or nearest neighbor sampling (possibly with aspect ratio change) to a
+/// common output size specified by `crop_size`. This is more general than the
+/// `crop_to_bounding_box` op which extracts a fixed size slice from the input image
+/// and does not allow resizing or aspect ratio change.
+///
+/// Returns a tensor with `crops` from the input `image` at positions defined at the
+/// bounding box locations in `boxes`. The cropped boxes are all resized (with
+/// bilinear or nearest neighbor interpolation) to a fixed
+/// `size = [crop_height, crop_width]`. The result is a 4-D tensor
+/// `[num_boxes, crop_height, crop_width, depth]`. The resizing is corner aligned.
+/// In particular, if `boxes = [[0, 0, 1, 1]]`, the method will give identical
+/// results to using `tf.image.resize_bilinear()` or
+/// `tf.image.resize_nearest_neighbor()`(depends on the `method` argument) with
+/// `align_corners=True`.
+///
+/// - Parameters:
+///     - image: A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
+///         Both `image_height` and `image_width` need to be positive.
+///     - boxes: A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
+///         specifies the coordinates of a box in the `box_ind[i]` image and is specified
+///         in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of
+///         `y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the
+///         `[0, 1]` interval of normalized image height is mapped to
+///         `[0, image_height - 1]` in image height coordinates. We do allow `y1` > `y2`, in
+///         which case the sampled crop is an up-down flipped version of the original
+///         image. The width dimension is treated similarly. Normalized coordinates
+///         outside the `[0, 1]` range are allowed, in which case we use
+///         `extrapolation_value` to extrapolate the input image values.
+///     - box_ind: A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
+///         The value of `box_ind[i]` specifies the image that the `i`-th box refers to.
+///     - crop_size: A 1-D tensor of 2 elements, `size = [crop_height, crop_width]`. All
+///         cropped image patches are resized to this size. The aspect ratio of the image
+///         content is not preserved. Both `crop_height` and `crop_width` need to be
+///         positive.
+///
+/// - Attrs:
+///     - method: A string specifying the sampling method for resizing. It can be either
+///         `"bilinear"` or `"nearest"` and default to `"bilinear"`. Currently two sampling
+///         methods are supported: Bilinear and Nearest Neighbor.
+///     - extrapolation_value: Value used for extrapolation, when applicable.
+///
+/// - Output crops: A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
+@inlinable @inline(__always)
+public static func cropAndResize<T: Numeric & TensorFlowScalar>(
+    image: Tensor<T>,
+    boxes: Tensor<Float>,
+    boxInd: Tensor<Int32>,
+    cropSize: Tensor<Int32>,
+    method: Method = .bilinear,
+    extrapolationValue: Double = 0
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("CropAndResize", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("method", method.cName)
+    op.updateAttribute("extrapolation_value", extrapolationValue)
+    op.addInput(image)
+    op.addInput(boxes)
+    op.addInput(boxInd)
+    op.addInput(cropSize)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient of the crop_and_resize op wrt the input boxes tensor.
+///
+/// - Parameters:
+///     - grads: A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
+///     - image: A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
+///         Both `image_height` and `image_width` need to be positive.
+///     - boxes: A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
+///         specifies the coordinates of a box in the `box_ind[i]` image and is specified
+///         in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of
+///         `y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the
+///         `[0, 1]` interval of normalized image height is mapped to
+///         `[0, image_height - 1] in image height coordinates. We do allow y1 > y2, in
+///         which case the sampled crop is an up-down flipped version of the original
+///         image. The width dimension is treated similarly. Normalized coordinates
+///         outside the `[0, 1]` range are allowed, in which case we use
+///         `extrapolation_value` to extrapolate the input image values.
+///     - box_ind: A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
+///         The value of `box_ind[i]` specifies the image that the `i`-th box refers to.
+///
+/// - Attr method: A string specifying the interpolation method. Only 'bilinear' is
+///     supported for now.
+///
+/// - Output output: A 2-D tensor of shape `[num_boxes, 4]`.
+@inlinable @inline(__always)
+public static func cropAndResizeGradBoxes<T: Numeric & TensorFlowScalar>(
+    grads: Tensor<Float>,
+    image: Tensor<T>,
+    boxes: Tensor<Float>,
+    boxInd: Tensor<Int32>,
+    method: Method3 = .bilinear
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("CropAndResizeGradBoxes", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("method", method.cName)
+    op.addInput(grads)
+    op.addInput(image)
+    op.addInput(boxes)
+    op.addInput(boxInd)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient of the crop_and_resize op wrt the input image tensor.
+///
+/// - Parameters:
+///     - grads: A 4-D tensor of shape `[num_boxes, crop_height, crop_width, depth]`.
+///     - boxes: A 2-D tensor of shape `[num_boxes, 4]`. The `i`-th row of the tensor
+///         specifies the coordinates of a box in the `box_ind[i]` image and is specified
+///         in normalized coordinates `[y1, x1, y2, x2]`. A normalized coordinate value of
+///         `y` is mapped to the image coordinate at `y * (image_height - 1)`, so as the
+///         `[0, 1]` interval of normalized image height is mapped to
+///         `[0, image_height - 1] in image height coordinates. We do allow y1 > y2, in
+///         which case the sampled crop is an up-down flipped version of the original
+///         image. The width dimension is treated similarly. Normalized coordinates
+///         outside the `[0, 1]` range are allowed, in which case we use
+///         `extrapolation_value` to extrapolate the input image values.
+///     - box_ind: A 1-D tensor of shape `[num_boxes]` with int32 values in `[0, batch)`.
+///         The value of `box_ind[i]` specifies the image that the `i`-th box refers to.
+///     - image_size: A 1-D tensor with value `[batch, image_height, image_width, depth]`
+///         containing the original image size. Both `image_height` and `image_width` need
+///         to be positive.
+///
+/// - Attr method: A string specifying the interpolation method. Only 'bilinear' is
+///     supported for now.
+///
+/// - Output output: A 4-D tensor of shape `[batch, image_height, image_width, depth]`.
+@inlinable @inline(__always)
+public static func cropAndResizeGradImage<T: FloatingPoint & TensorFlowScalar>(
+    grads: Tensor<Float>,
+    boxes: Tensor<Float>,
+    boxInd: Tensor<Int32>,
+    imageSize: Tensor<Int32>,
+    method: Method = .bilinear
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("CropAndResizeGradImage", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("method", method.cName)
+    op.addInput(grads)
+    op.addInput(boxes)
+    op.addInput(boxInd)
+    op.addInput(imageSize)
+    return op.execute(Int(1))
+}
+
+/// Compute the pairwise cross product.
+///
+/// `a` and `b` must be the same shape; they can either be simple 3-element vectors,
+/// or any shape where the innermost dimension is 3. In the latter case, each pair
+/// of corresponding 3-element vectors is cross-multiplied independently.
+///
+/// - Parameters:
+///     - a: A tensor containing 3-element vectors.
+///     - b: Another tensor, of same type and shape as `a`.
+///
+/// - Output product: Pairwise cross product of the vectors in `a` and `b`.
+@inlinable @inline(__always)
+public static func cross<T: Numeric & TensorFlowScalar>(
+    _ a: Tensor<T>,
+    _ b: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Cross", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    op.addInput(b)
+    return op.execute(Int(1))
+}
+
+/// An Op to sum inputs across replicated TPU instances.
+///
+/// Each instance supplies its own input.
+///
+/// For example, suppose there are 8 TPU instances: `[A, B, C, D, E, F, G, H]`.
+/// Passing group_assignment=`[[0,2,4,6],[1,3,5,7]]` sets `A, C, E, G` as group 0,
+/// and `B, D, F, H` as group 1. Thus we get the outputs:
+/// `[A+C+E+G, B+D+F+H, A+C+E+G, B+D+F+H, A+C+E+G, B+D+F+H, A+C+E+G, B+D+F+H]`.
+///
+/// - Parameters:
+///     - input: The local input to the sum.
+///     - group_assignment: An int32 tensor with shape
+///         [num_groups, num_replicas_per_group]. `group_assignment[i]` represents the
+///         replica ids in the ith subgroup.
+///
+/// - Attr T: The type of elements to be summed.
+///
+/// - Output output: The sum of all the distributed inputs.
+@inlinable @inline(__always)
+public static func crossReplicaSum<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    groupAssignment: Tensor<Int32>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("CrossReplicaSum", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(groupAssignment)
+    return op.execute(Int(1))
+}
+
+/// A RNN backed by cuDNN.
+///
+/// Computes the RNN from the input and initial states, with respect to the params
+/// buffer.
+///
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicate whether there is a linear projection between the input and
+///   the actual computation before the first layer. 'skip_input' is only allowed
+///   when input_size == num_units; 'auto_select' implies 'skip_input' when
+///   input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used. Should be
+///   "unidirectional" or "bidirectional".
+/// dropout: Dropout probability. When set to 0., dropout is disabled.
+/// seed: The 1st part of a seed to initialize dropout.
+/// seed2: The 2nd part of a seed to initialize dropout.
+/// input: A 3-D tensor with the shape of [seq_length, batch_size, input_size].
+/// input_h: A 3-D tensor with the shape of [num_layer * dir, batch_size,
+///     num_units].
+/// input_c: For LSTM, a 3-D tensor with the shape of
+///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
+/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
+///     The size must be created through CudnnRNNParamsSize, and initialized
+///     separately. Note that they might not be compatible across different
+///     generations. So it is a good idea to save and restore
+/// output: A 3-D tensor with the shape of [seq_length, batch_size,
+///     dir * num_units].
+/// output_h: The same shape has input_h.
+/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
+/// is_training: Indicates whether this operation is used for inferenece or
+///   training.
+/// reserve_space: An opaque tensor that can be used in backprop calculation. It
+///   is only produced if is_training is false.
+@inlinable @inline(__always)
+public static func cudnnRNN<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    inputH: Tensor<T>,
+    inputC: Tensor<T>,
+    params: Tensor<T>,
+    rnnMode: RnnMode = .lstm,
+    inputMode: InputMode = .linearInput,
+    direction: Direction = .unidirectional,
+    dropout: Double = 0,
+    seed: Int64 = 0,
+    seed2: Int64 = 0,
+    isTraining: Bool = true
+) -> (output: Tensor<T>, outputH: Tensor<T>, outputC: Tensor<T>, reserveSpace: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("CudnnRNN", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("rnn_mode", rnnMode.cName)
+    op.updateAttribute("input_mode", inputMode.cName)
+    op.updateAttribute("direction", direction.cName)
+    op.updateAttribute("dropout", dropout)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("is_training", isTraining)
+    op.addInput(input)
+    op.addInput(inputH)
+    op.addInput(inputC)
+    op.addInput(params)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Backprop step of CudnnRNN.
+///
+/// Compute the backprop of both data and weights in a RNN.
+///
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicate whether there is a linear projection between the input and
+///     the actual computation before the first layer. 'skip_input' is only allowed
+///     when input_size == num_units; 'auto_select' implies 'skip_input' when
+///     input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used. Should be
+///   "unidirectional" or "bidirectional".
+/// dropout: Dropout probability. When set to 0., dropout is disabled.
+/// seed: The 1st part of a seed to initialize dropout.
+/// seed2: The 2nd part of a seed to initialize dropout.
+/// input: A 3-D tensor with the shape of [seq_length, batch_size, input_size].
+/// input_h: A 3-D tensor with the shape of [num_layer * dir, batch_size,
+///     num_units].
+/// input_c: For LSTM, a 3-D tensor with the shape of
+///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
+/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
+///     The size must be created through CudnnRNNParamsSize, and initialized
+///     separately. Note that they might not be compatible across different
+///     generations. So it is a good idea to save and restore
+/// output: A 3-D tensor with the shape of [seq_length, batch_size,
+///     dir * num_units].
+/// output_h: The same shape has input_h.
+/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
+/// output_backprop: A 3-D tensor with the same shape as output in the forward pass.
+/// output_h_backprop: A 3-D tensor with the same shape as output_h in the forward
+///     pass.
+/// output_c_backprop: A 3-D tensor with the same shape as output_c in the forward
+///     pass.
+/// reserve_space: The same reserve_space produced in for forward operation.
+/// input_backprop: The backprop to input in the forward pass. Has the same shape
+///     as input.
+/// input_h_backprop: The backprop to input_h in the forward pass. Has the same
+///     shape as input_h.
+/// input_c_backprop: The backprop to input_c in the forward pass. Has the same
+///     shape as input_c.
+/// params_backprop: The backprop to the params buffer in the forward pass. Has the
+///     same shape as params.
+@inlinable @inline(__always)
+public static func cudnnRNNBackprop<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    inputH: Tensor<T>,
+    inputC: Tensor<T>,
+    params: Tensor<T>,
+    output: Tensor<T>,
+    outputH: Tensor<T>,
+    outputC: Tensor<T>,
+    outputBackprop: Tensor<T>,
+    outputHBackprop: Tensor<T>,
+    outputCBackprop: Tensor<T>,
+    reserveSpace: Tensor<T>,
+    rnnMode: RnnMode = .lstm,
+    inputMode: InputMode = .linearInput,
+    direction: Direction = .unidirectional,
+    dropout: Double = 0,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> (inputBackprop: Tensor<T>, inputHBackprop: Tensor<T>, inputCBackprop: Tensor<T>, paramsBackprop: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("CudnnRNNBackprop", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("rnn_mode", rnnMode.cName)
+    op.updateAttribute("input_mode", inputMode.cName)
+    op.updateAttribute("direction", direction.cName)
+    op.updateAttribute("dropout", dropout)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(input)
+    op.addInput(inputH)
+    op.addInput(inputC)
+    op.addInput(params)
+    op.addInput(output)
+    op.addInput(outputH)
+    op.addInput(outputC)
+    op.addInput(outputBackprop)
+    op.addInput(outputHBackprop)
+    op.addInput(outputCBackprop)
+    op.addInput(reserveSpace)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Backprop step of CudnnRNN.
+///
+/// Compute the backprop of both data and weights in a RNN. Takes an extra
+///     "host_reserved" inupt than CudnnRNNBackprop, which is used to determine RNN
+///     cudnnRNNAlgo_t and cudnnMathType_t.
+///
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicates whether there is a linear projection between the input and
+///     the actual computation before the first layer. 'skip_input' is only allowed
+///     when input_size == num_units; 'auto_select' implies 'skip_input' when
+///     input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used. Should be
+///   "unidirectional" or "bidirectional".
+/// dropout: Dropout probability. When set to 0., dropout is disabled.
+/// seed: The 1st part of a seed to initialize dropout.
+/// seed2: The 2nd part of a seed to initialize dropout.
+/// input: A 3-D tensor with the shape of [seq_length, batch_size, input_size].
+/// input_h: A 3-D tensor with the shape of [num_layer * dir, batch_size,
+///     num_units].
+/// input_c: For LSTM, a 3-D tensor with the shape of
+///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
+/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
+///     The size must be created through CudnnRNNParamsSize, and initialized
+///     separately. Note that they might not be compatible across different
+///     generations. So it is a good idea to save and restore
+/// output: A 3-D tensor with the shape of [seq_length, batch_size,
+///     dir * num_units].
+/// output_h: The same shape has input_h.
+/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
+/// output_backprop: A 3-D tensor with the same shape as output in the forward pass.
+/// output_h_backprop: A 3-D tensor with the same shape as output_h in the forward
+///     pass.
+/// output_c_backprop: A 3-D tensor with the same shape as output_c in the forward
+///     pass.
+/// reserve_space: The same reserve_space produced in the forward operation.
+/// host_reserved: The same host_reserved produced in the forward operation.
+/// input_backprop: The backprop to input in the forward pass. Has the same shape
+///     as input.
+/// input_h_backprop: The backprop to input_h in the forward pass. Has the same
+///     shape as input_h.
+/// input_c_backprop: The backprop to input_c in the forward pass. Has the same
+///     shape as input_c.
+/// params_backprop: The backprop to the params buffer in the forward pass. Has the
+///     same shape as params.
+@inlinable @inline(__always)
+public static func cudnnRNNBackpropV2<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    inputH: Tensor<T>,
+    inputC: Tensor<T>,
+    params: Tensor<T>,
+    output: Tensor<T>,
+    outputH: Tensor<T>,
+    outputC: Tensor<T>,
+    outputBackprop: Tensor<T>,
+    outputHBackprop: Tensor<T>,
+    outputCBackprop: Tensor<T>,
+    reserveSpace: Tensor<T>,
+    hostReserved: Tensor<Int8>,
+    rnnMode: RnnMode = .lstm,
+    inputMode: InputMode = .linearInput,
+    direction: Direction = .unidirectional,
+    dropout: Double = 0,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> (inputBackprop: Tensor<T>, inputHBackprop: Tensor<T>, inputCBackprop: Tensor<T>, paramsBackprop: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("CudnnRNNBackpropV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("rnn_mode", rnnMode.cName)
+    op.updateAttribute("input_mode", inputMode.cName)
+    op.updateAttribute("direction", direction.cName)
+    op.updateAttribute("dropout", dropout)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(input)
+    op.addInput(inputH)
+    op.addInput(inputC)
+    op.addInput(params)
+    op.addInput(output)
+    op.addInput(outputH)
+    op.addInput(outputC)
+    op.addInput(outputBackprop)
+    op.addInput(outputHBackprop)
+    op.addInput(outputCBackprop)
+    op.addInput(reserveSpace)
+    op.addInput(hostReserved)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Backprop step of CudnnRNNV3.
+///
+/// Compute the backprop of both data and weights in a RNN. Takes an extra
+///     "sequence_lengths" input than CudnnRNNBackprop.
+///
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicates whether there is a linear projection between the input and
+///     the actual computation before the first layer. 'skip_input' is only allowed
+///     when input_size == num_units; 'auto_select' implies 'skip_input' when
+///     input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used. Should be
+///   "unidirectional" or "bidirectional".
+/// dropout: Dropout probability. When set to 0., dropout is disabled.
+/// seed: The 1st part of a seed to initialize dropout.
+/// seed2: The 2nd part of a seed to initialize dropout.
+/// input: If time_major is true, this is a 3-D tensor with the shape of
+///     [seq_length, batch_size, input_size]. If time_major is false, the shape is
+///     [batch_size, seq_length, input_size].
+/// input_h: If time_major is true, this is a 3-D tensor with the shape of
+///     [num_layer * dir, batch_size, num_units]. If time_major is false, the shape
+///     is [batch_size, num_layer * dir, num_units].
+/// input_c: For LSTM, a 3-D tensor with the shape of
+///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
+/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
+///     The size must be created through CudnnRNNParamsSize, and initialized
+///     separately. Note that they might not be compatible across different
+///     generations. So it is a good idea to save and restore
+/// sequence_lengths: a vector of lengths of each input sequence.
+/// output: If time_major is true, this is a 3-D tensor with the shape of
+///     [seq_length, batch_size, dir * num_units]. If time_major is false, the
+///     shape is [batch_size, seq_length, dir * num_units].
+/// output_h: The same shape has input_h.
+/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
+/// output_backprop: A 3-D tensor with the same shape as output in the forward pass.
+/// output_h_backprop: A 3-D tensor with the same shape as output_h in the forward
+///     pass.
+/// output_c_backprop: A 3-D tensor with the same shape as output_c in the forward
+///     pass.
+/// time_major: Indicates whether the input/output format is time major or batch
+///     major.
+/// reserve_space: The same reserve_space produced in the forward operation.
+/// input_backprop: The backprop to input in the forward pass. Has the same shape
+///     as input.
+/// input_h_backprop: The backprop to input_h in the forward pass. Has the same
+///     shape as input_h.
+/// input_c_backprop: The backprop to input_c in the forward pass. Has the same
+///     shape as input_c.
+/// params_backprop: The backprop to the params buffer in the forward pass. Has the
+///     same shape as params.
+@inlinable @inline(__always)
+public static func cudnnRNNBackpropV3<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    inputH: Tensor<T>,
+    inputC: Tensor<T>,
+    params: Tensor<T>,
+    sequenceLengths: Tensor<Int32>,
+    output: Tensor<T>,
+    outputH: Tensor<T>,
+    outputC: Tensor<T>,
+    outputBackprop: Tensor<T>,
+    outputHBackprop: Tensor<T>,
+    outputCBackprop: Tensor<T>,
+    reserveSpace: Tensor<T>,
+    hostReserved: Tensor<Int8>,
+    rnnMode: RnnMode = .lstm,
+    inputMode: InputMode = .linearInput,
+    direction: Direction = .unidirectional,
+    dropout: Double = 0,
+    seed: Int64 = 0,
+    seed2: Int64 = 0,
+    timeMajor: Bool = true
+) -> (inputBackprop: Tensor<T>, inputHBackprop: Tensor<T>, inputCBackprop: Tensor<T>, paramsBackprop: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("CudnnRNNBackpropV3", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("rnn_mode", rnnMode.cName)
+    op.updateAttribute("input_mode", inputMode.cName)
+    op.updateAttribute("direction", direction.cName)
+    op.updateAttribute("dropout", dropout)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("time_major", timeMajor)
+    op.addInput(input)
+    op.addInput(inputH)
+    op.addInput(inputC)
+    op.addInput(params)
+    op.addInput(sequenceLengths)
+    op.addInput(output)
+    op.addInput(outputH)
+    op.addInput(outputC)
+    op.addInput(outputBackprop)
+    op.addInput(outputHBackprop)
+    op.addInput(outputCBackprop)
+    op.addInput(reserveSpace)
+    op.addInput(hostReserved)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Converts CudnnRNN params from canonical form to usable form.
+///
+/// Writes a set of weights into the opaque params buffer so they can be used in
+/// upcoming training or inferences.
+///
+/// Note that the params buffer may not be compatible across different GPUs. So any
+/// save and restoration should be converted to and from the canonical weights and
+/// biases.
+///
+/// num_layers: Specifies the number of layers in the RNN model.
+/// num_units: Specifies the size of the hidden state.
+/// input_size: Specifies the size of the input state.
+/// weights: the canonical form of weights that can be used for saving
+///     and restoration. They are more likely to be compatible across different
+///     generations.
+/// biases: the canonical form of biases that can be used for saving
+///     and restoration. They are more likely to be compatible across different
+///     generations.
+/// num_params: number of parameter sets for all layers.
+///     Each layer may contain multiple parameter sets, with each set consisting of
+///     a weight matrix and a bias vector.
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicate whether there is a linear projection between the input and
+///     The actual computation before the first layer. 'skip_input' is only allowed
+///     when input_size == num_units; 'auto_select' implies 'skip_input' when
+///     input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used.
+///     dir = (direction == bidirectional) ? 2 : 1
+/// dropout: dropout probability. When set to 0., dropout is disabled.
+/// seed: the 1st part of a seed to initialize dropout.
+/// seed2: the 2nd part of a seed to initialize dropout.
+@inlinable @inline(__always)
+public static func cudnnRNNCanonicalToParams<T: FloatingPoint & TensorFlowScalar>(
+    numLayers: Tensor<Int32>,
+    numUnits: Tensor<Int32>,
+    inputSize: Tensor<Int32>,
+    weights: [Tensor<T>],
+    biases: [Tensor<T>],
+    rnnMode: RnnMode = .lstm,
+    inputMode: InputMode = .linearInput,
+    direction: Direction = .unidirectional,
+    dropout: Double = 0,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("CudnnRNNCanonicalToParams", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("num_params", weights.count)
+    op.updateAttribute("rnn_mode", rnnMode.cName)
+    op.updateAttribute("input_mode", inputMode.cName)
+    op.updateAttribute("direction", direction.cName)
+    op.updateAttribute("dropout", dropout)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(numLayers)
+    op.addInput(numUnits)
+    op.addInput(inputSize)
+    op.addInputList(weights)
+    op.addInputList(biases)
+    return op.execute(Int(1))
+}
+
+/// Computes size of weights that can be used by a Cudnn RNN model.
+///
+/// Return the params size that can be used by the Cudnn RNN model. Subsequent
+/// weight allocation and initialization should use this size.
+///
+/// num_layers: Specifies the number of layers in the RNN model.
+/// num_units: Specifies the size of the hidden state.
+/// input_size: Specifies the size of the input state.
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicate whether there is a linear projection between the input and
+///   The actual computation before the first layer. 'skip_input' is only allowed
+///   when input_size == num_units; 'auto_select' implies 'skip_input' when
+///   input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used.
+///   dir = (direction == bidirectional) ? 2 : 1
+/// dropout: dropout probability. When set to 0., dropout is disabled.
+/// seed: the 1st part of a seed to initialize dropout.
+/// seed2: the 2nd part of a seed to initialize dropout.
+/// params_size: The size of the params buffer that should be allocated and
+///   initialized for this RNN model. Note that this params buffer may not be
+///   compatible across GPUs. Please use CudnnRNNParamsWeights and
+///   CudnnRNNParamsBiases to save and restore them in a way that is compatible
+///   across different runs.
+@inlinable @inline(__always)
+public static func cudnnRNNParamsSize<S: BinaryInteger & TensorFlowScalar>(
+    numLayers: Tensor<Int32>,
+    numUnits: Tensor<Int32>,
+    inputSize: Tensor<Int32>,
+    t: TensorDataType,
+    rnnMode: RnnMode = .lstm,
+    inputMode: InputMode = .linearInput,
+    direction: Direction = .unidirectional,
+    dropout: Double = 0,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<S> {
+  let nOutputs = Int(1)
+    let op = makeOp("CudnnRNNParamsSize", nOutputs)
+    op.updateAttribute("T", t)
+    op.updateAttribute("S", S.tensorFlowDataType)
+    op.updateAttribute("rnn_mode", rnnMode.cName)
+    op.updateAttribute("input_mode", inputMode.cName)
+    op.updateAttribute("direction", direction.cName)
+    op.updateAttribute("dropout", dropout)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(numLayers)
+    op.addInput(numUnits)
+    op.addInput(inputSize)
+    return op.execute(Int(1))
+}
+
+/// Retrieves CudnnRNN params in canonical form.
+///
+/// Retrieves a set of weights from the opaque params buffer that can be saved and
+/// restored in a way compatible with future runs.
+///
+/// Note that the params buffer may not be compatible across different GPUs. So any
+/// save and restoration should be converted to and from the canonical weights and
+/// biases.
+///
+/// num_layers: Specifies the number of layers in the RNN model.
+/// num_units: Specifies the size of the hidden state.
+/// input_size: Specifies the size of the input state.
+/// num_params: number of parameter sets for all layers.
+///     Each layer may contain multiple parameter sets, with each set consisting of
+///     a weight matrix and a bias vector.
+/// weights: the canonical form of weights that can be used for saving
+///     and restoration. They are more likely to be compatible across different
+///     generations.
+/// biases: the canonical form of biases that can be used for saving
+///     and restoration. They are more likely to be compatible across different
+///     generations.
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicate whether there is a linear projection between the input and
+///     The actual computation before the first layer. 'skip_input' is only allowed
+///     when input_size == num_units; 'auto_select' implies 'skip_input' when
+///     input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used.
+///     dir = (direction == bidirectional) ? 2 : 1
+/// dropout: dropout probability. When set to 0., dropout is disabled.
+/// seed: the 1st part of a seed to initialize dropout.
+/// seed2: the 2nd part of a seed to initialize dropout.
+@inlinable @inline(__always)
+public static func cudnnRNNParamsToCanonical<T: FloatingPoint & TensorFlowScalar>(
+    numLayers: Tensor<Int32>,
+    numUnits: Tensor<Int32>,
+    inputSize: Tensor<Int32>,
+    params: Tensor<T>,
+    numParams: Int64,
+    rnnMode: RnnMode = .lstm,
+    inputMode: InputMode = .linearInput,
+    direction: Direction = .unidirectional,
+    dropout: Double = 0,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> (weights: [Tensor<T>], biases: [Tensor<T>]) {
+  let nOutputs = Int(numParams) + Int(numParams)
+    let op = makeOp("CudnnRNNParamsToCanonical", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("num_params", numParams)
+    op.updateAttribute("rnn_mode", rnnMode.cName)
+    op.updateAttribute("input_mode", inputMode.cName)
+    op.updateAttribute("direction", direction.cName)
+    op.updateAttribute("dropout", dropout)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(numLayers)
+    op.addInput(numUnits)
+    op.addInput(inputSize)
+    op.addInput(params)
+    return op.execute(Int(numParams), Int(numParams))
+}
+
+/// A RNN backed by cuDNN.
+///
+/// Computes the RNN from the input and initial states, with respect to the params
+/// buffer. Produces one extra output "host_reserved" than CudnnRNN.
+///
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicates whether there is a linear projection between the input and
+///   the actual computation before the first layer. 'skip_input' is only allowed
+///   when input_size == num_units; 'auto_select' implies 'skip_input' when
+///   input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used. Should be
+///   "unidirectional" or "bidirectional".
+/// dropout: Dropout probability. When set to 0., dropout is disabled.
+/// seed: The 1st part of a seed to initialize dropout.
+/// seed2: The 2nd part of a seed to initialize dropout.
+/// input: A 3-D tensor with the shape of [seq_length, batch_size, input_size].
+/// input_h: A 3-D tensor with the shape of [num_layer * dir, batch_size,
+///     num_units].
+/// input_c: For LSTM, a 3-D tensor with the shape of
+///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
+/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
+///     The size must be created through CudnnRNNParamsSize, and initialized
+///     separately. Note that they might not be compatible across different
+///     generations. So it is a good idea to save and restore
+/// output: A 3-D tensor with the shape of [seq_length, batch_size,
+///     dir * num_units].
+/// output_h: The same shape has input_h.
+/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
+/// is_training: Indicates whether this operation is used for inferenece or
+///   training.
+/// reserve_space: An opaque tensor that can be used in backprop calculation. It
+///   is only produced if is_training is true.
+/// host_reserved: An opaque tensor that can be used in backprop calculation. It is
+///   only produced if is_training is true. It is output on host memory rather than
+///   device memory.
+@inlinable @inline(__always)
+public static func cudnnRNNV2<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    inputH: Tensor<T>,
+    inputC: Tensor<T>,
+    params: Tensor<T>,
+    rnnMode: RnnMode = .lstm,
+    inputMode: InputMode = .linearInput,
+    direction: Direction = .unidirectional,
+    dropout: Double = 0,
+    seed: Int64 = 0,
+    seed2: Int64 = 0,
+    isTraining: Bool = true
+) -> (output: Tensor<T>, outputH: Tensor<T>, outputC: Tensor<T>, reserveSpace: Tensor<T>, hostReserved: Tensor<Int8>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("CudnnRNNV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("rnn_mode", rnnMode.cName)
+    op.updateAttribute("input_mode", inputMode.cName)
+    op.updateAttribute("direction", direction.cName)
+    op.updateAttribute("dropout", dropout)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("is_training", isTraining)
+    op.addInput(input)
+    op.addInput(inputH)
+    op.addInput(inputC)
+    op.addInput(params)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// A RNN backed by cuDNN.
+///
+/// Computes the RNN from the input and initial states, with respect to the params
+/// buffer. Accepts one extra input "sequence_lengths" than CudnnRNN.
+///
+/// rnn_mode: Indicates the type of the RNN model.
+/// input_mode: Indicates whether there is a linear projection between the input and
+///   the actual computation before the first layer. 'skip_input' is only allowed
+///   when input_size == num_units; 'auto_select' implies 'skip_input' when
+///   input_size == num_units; otherwise, it implies 'linear_input'.
+/// direction: Indicates whether a bidirectional model will be used. Should be
+///   "unidirectional" or "bidirectional".
+/// dropout: Dropout probability. When set to 0., dropout is disabled.
+/// seed: The 1st part of a seed to initialize dropout.
+/// seed2: The 2nd part of a seed to initialize dropout.
+/// input: If time_major is true, this is a 3-D tensor with the shape of
+///     [seq_length, batch_size, input_size]. If time_major is false, the shape is
+///     [batch_size, seq_length, input_size].
+/// input_h: If time_major is true, this is a 3-D tensor with the shape of
+///     [num_layer * dir, batch_size, num_units]. If time_major is false, the shape
+///     is [batch_size, num_layer * dir, num_units].
+/// input_c: For LSTM, a 3-D tensor with the shape of
+///     [num_layer * dir, batch, num_units]. For other models, it is ignored.
+/// params: A 1-D tensor that contains the weights and biases in an opaque layout.
+///     The size must be created through CudnnRNNParamsSize, and initialized
+///     separately. Note that they might not be compatible across different
+///     generations. So it is a good idea to save and restore
+/// sequence_lengths: a vector of lengths of each input sequence.
+/// output: If time_major is true, this is a 3-D tensor with the shape of
+///     [seq_length, batch_size, dir * num_units]. If time_major is false, the
+///     shape is [batch_size, seq_length, dir * num_units].
+/// output_h: The same shape has input_h.
+/// output_c: The same shape as input_c for LSTM. An empty tensor for other models.
+/// is_training: Indicates whether this operation is used for inferenece or
+///   training.
+/// time_major: Indicates whether the input/output format is time major or batch
+///     major.
+/// reserve_space: An opaque tensor that can be used in backprop calculation. It
+///   is only produced if is_training is true.
+@inlinable @inline(__always)
+public static func cudnnRNNV3<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    inputH: Tensor<T>,
+    inputC: Tensor<T>,
+    params: Tensor<T>,
+    sequenceLengths: Tensor<Int32>,
+    rnnMode: RnnMode = .lstm,
+    inputMode: InputMode = .linearInput,
+    direction: Direction = .unidirectional,
+    dropout: Double = 0,
+    seed: Int64 = 0,
+    seed2: Int64 = 0,
+    isTraining: Bool = true,
+    timeMajor: Bool = true
+) -> (output: Tensor<T>, outputH: Tensor<T>, outputC: Tensor<T>, reserveSpace: Tensor<T>, hostReserved: Tensor<Int8>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("CudnnRNNV3", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("rnn_mode", rnnMode.cName)
+    op.updateAttribute("input_mode", inputMode.cName)
+    op.updateAttribute("direction", direction.cName)
+    op.updateAttribute("dropout", dropout)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("is_training", isTraining)
+    op.updateAttribute("time_major", timeMajor)
+    op.addInput(input)
+    op.addInput(inputH)
+    op.addInput(inputC)
+    op.addInput(params)
+    op.addInput(sequenceLengths)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Compute the cumulative product of the tensor `x` along `axis`.
+///
+/// By default, this op performs an inclusive cumprod, which means that the first
+/// element of the input is identical to the first element of the output:
+///
+/// ```python
+/// tf.cumprod([a, b, c])  # => [a, a * b, a * b * c]
+/// ```
+///
+/// By setting the `exclusive` kwarg to `True`, an exclusive cumprod is
+/// performed instead:
+///
+/// ```python
+/// tf.cumprod([a, b, c], exclusive=True)  # => [1, a, a * b]
+/// ```
+///
+/// By setting the `reverse` kwarg to `True`, the cumprod is performed in the
+/// opposite direction:
+///
+/// ```python
+/// tf.cumprod([a, b, c], reverse=True)  # => [a * b * c, b * c, c]
+/// ```
+///
+/// This is more efficient than using separate `tf.reverse` ops.
+///
+/// The `reverse` and `exclusive` kwargs can also be combined:
+///
+/// ```python
+/// tf.cumprod([a, b, c], exclusive=True, reverse=True)  # => [b * c, c, 1]
+/// ```
+///
+/// - Parameters:
+///     - x: A `Tensor`. Must be one of the following types: `float32`, `float64`,
+///         `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,
+///         `complex128`, `qint8`, `quint8`, `qint32`, `half`.
+///     - axis: A `Tensor` of type `int32` (default: 0). Must be in the range
+///         `[-rank(x), rank(x))`.
+///
+/// - Attrs:
+///     - exclusive: If `True`, perform exclusive cumprod.
+///     - reverse: A `bool` (default: False).
+@inlinable @inline(__always)
+public static func cumprod<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    _ x: Tensor<T>,
+    axis: Tensor<Tidx>,
+    exclusive: Bool = false,
+    reverse: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Cumprod", nOutputs)
+    op.updateAttribute("exclusive", exclusive)
+    op.updateAttribute("reverse", reverse)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(axis)
+    return op.execute(Int(1))
+}
+
+/// Compute the cumulative sum of the tensor `x` along `axis`.
+///
+/// By default, this op performs an inclusive cumsum, which means that the first
+/// element of the input is identical to the first element of the output:
+///
+/// ```python
+/// tf.cumsum([a, b, c])  # => [a, a + b, a + b + c]
+/// ```
+///
+/// By setting the `exclusive` kwarg to `True`, an exclusive cumsum is
+/// performed instead:
+///
+/// ```python
+/// tf.cumsum([a, b, c], exclusive=True)  # => [0, a, a + b]
+/// ```
+///
+/// By setting the `reverse` kwarg to `True`, the cumsum is performed in the
+/// opposite direction:
+///
+/// ```python
+/// tf.cumsum([a, b, c], reverse=True)  # => [a + b + c, b + c, c]
+/// ```
+///
+/// This is more efficient than using separate `tf.reverse` ops.
+///
+/// The `reverse` and `exclusive` kwargs can also be combined:
+///
+/// ```python
+/// tf.cumsum([a, b, c], exclusive=True, reverse=True)  # => [b + c, c, 0]
+/// ```
+///
+/// - Parameters:
+///     - x: A `Tensor`. Must be one of the following types: `float32`, `float64`,
+///         `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`,
+///         `complex128`, `qint8`, `quint8`, `qint32`, `half`.
+///     - axis: A `Tensor` of type `int32` (default: 0). Must be in the range
+///         `[-rank(x), rank(x))`.
+///
+/// - Attrs:
+///     - exclusive: If `True`, perform exclusive cumsum.
+///     - reverse: A `bool` (default: False).
+@inlinable @inline(__always)
+public static func cumsum<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    _ x: Tensor<T>,
+    axis: Tensor<Tidx>,
+    exclusive: Bool = false,
+    reverse: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Cumsum", nOutputs)
+    op.updateAttribute("exclusive", exclusive)
+    op.updateAttribute("reverse", reverse)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(axis)
+    return op.execute(Int(1))
+}
+
+/// Returns the dimension index in the destination data format given the one in
+///
+/// the source data format.
+///
+/// - Parameter x: A Tensor with each element as a dimension index in source data format.
+///     Must be in the range [-4, 4).
+///
+/// - Attrs:
+///     - src_format: source data format.
+///     - dst_format: destination data format.
+///
+/// - Output y: A Tensor with each element as a dimension index in destination data format.
+@inlinable @inline(__always)
+public static func dataFormatDimMap<T: BinaryInteger & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    srcFormat: String = "NHWC",
+    dstFormat: String = "NCHW"
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DataFormatDimMap", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("src_format", srcFormat)
+    op.updateAttribute("dst_format", dstFormat)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns the permuted vector/tensor in the destination data format given the
+///
+/// one in the source data format.
+///
+/// - Parameter x: Vector of size 4 or Tensor of shape (4, 2) in source data format.
+///
+/// - Attrs:
+///     - src_format: source data format.
+///     - dst_format: destination data format.
+///
+/// - Output y: Vector of size 4 or Tensor of shape (4, 2) in destination data format.
+@inlinable @inline(__always)
+public static func dataFormatVecPermute<T: BinaryInteger & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    srcFormat: String = "NHWC",
+    dstFormat: String = "NCHW"
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DataFormatVecPermute", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("src_format", srcFormat)
+    op.updateAttribute("dst_format", dstFormat)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns a serialized GraphDef representing `input_dataset`.
+///
+/// Returns a graph representation for `input_dataset`.
+///
+/// - Parameter input_dataset: A variant tensor representing the dataset to return the graph representation for.
+///
+/// - Output graph: The graph representation of the dataset (as serialized GraphDef).
+@inlinable @inline(__always)
+public static func datasetToGraph(
+    inputDataset: VariantHandle
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("DatasetToGraph", nOutputs)
+    op.addInput(inputDataset)
+    return op.execute(Int(1))
+}
+
+/// Outputs the single element from the given dataset.
+///
+/// - Parameter dataset: A handle to a dataset that contains a single element.
+///
+/// - Output components: The components of the single element of `input`.
+@inlinable @inline(__always)
+public static func datasetToSingleElement<OutputTypes: TensorGroup>(
+    dataset: VariantHandle,
+    outputShapes: [TensorShape?]
+) -> OutputTypes {
+  let nOutputs = Int(OutputTypes._typeList.count)
+    let op = makeOp("DatasetToSingleElement", nOutputs)
+    op.updateAttribute("output_types", OutputTypes._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(dataset)
+    return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Identity op for gradient debugging.
+///
+/// This op is hidden from public in Python. It is used by TensorFlow Debugger to
+/// register gradient tensors for gradient debugging.
+/// This op operates on non-reference-type tensors.
+@inlinable @inline(__always)
+public static func debugGradientIdentity<T: TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DebugGradientIdentity", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Debug Identity Op.
+///
+/// Provides an identity mapping of the non-Ref type input tensor for debugging.
+///
+/// - Parameter input: Input tensor, non-Reference type.
+///
+/// - Attrs:
+///     - tensor_name: Name of the input tensor.
+///     - debug_urls: List of URLs to debug targets, e.g.,
+///         file:///foo/tfdbg_dump, grpc:://localhost:11011
+///     - gated_grpc: Whether this op will be gated. If any of the debug_urls of this
+///         debug node is of the grpc:// scheme, when the value of this attribute is set
+///         to True, the data will not actually be sent via the grpc stream unless this
+///         debug op has been enabled at the debug_url. If all of the debug_urls of this
+///         debug node are of the grpc:// scheme and the debug op is enabled at none of
+///         them, the output will be an empty Tensor.
+///
+/// - Output output: Output tensor that equals the input tensor.
+@inlinable @inline(__always)
+public static func debugIdentity<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    deviceName: String,
+    tensorName: String,
+    debugUrls: [String],
+    gatedGrpc: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DebugIdentity", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("device_name", deviceName)
+    op.updateAttribute("tensor_name", tensorName)
+    op.updateAttribute("debug_urls", debugUrls)
+    op.updateAttribute("gated_grpc", gatedGrpc)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Debug NaN Value Counter Op
+///
+/// Counts number of NaNs in the input tensor, for debugging.
+///
+/// - Parameter input: Input tensor, non-Reference type.
+///
+/// - Attrs:
+///     - tensor_name: Name of the input tensor.
+///     - debug_urls: List of URLs to debug targets, e.g.,
+///         file:///foo/tfdbg_dump, grpc:://localhost:11011.
+///     - gated_grpc: Whether this op will be gated. If any of the debug_urls of this
+///         debug node is of the grpc:// scheme, when the value of this attribute is set
+///         to True, the data will not actually be sent via the grpc stream unless this
+///         debug op has been enabled at the debug_url. If all of the debug_urls of this
+///         debug node are of the grpc:// scheme and the debug op is enabled at none of
+///         them, the output will be an empty Tensor.
+///
+/// - Output output: An integer output tensor that is the number of NaNs in the input.
+@inlinable @inline(__always)
+public static func debugNanCount<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    deviceName: String,
+    tensorName: String,
+    debugUrls: [String],
+    gatedGrpc: Bool = false
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("DebugNanCount", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("device_name", deviceName)
+    op.updateAttribute("tensor_name", tensorName)
+    op.updateAttribute("debug_urls", debugUrls)
+    op.updateAttribute("gated_grpc", gatedGrpc)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Debug Numeric Summary Op.
+///
+/// Provide a basic summary of numeric value types, range and distribution.
+///
+/// - Parameter input: Input tensor, non-Reference type, float or double.
+///
+/// - Attrs:
+///     - tensor_name: Name of the input tensor.
+///     - debug_urls: List of URLs to debug targets, e.g.,
+///         file:///foo/tfdbg_dump, grpc:://localhost:11011
+///     - lower_bound: (float) The lower bound <= which values will be included in the
+///         generalized -inf count. Default: -inf.
+///     - upper_bound: (float) The upper bound >= which values will be included in the
+///         generalized +inf count. Default: +inf.
+///     - mute_if_healthy: (bool) Do not send data to the debug URLs unless at least one
+///         of elements [2], [3] and [7] (i.e., the nan count and the generalized -inf and
+///         inf counts) is non-zero.
+///     - gated_grpc: Whether this op will be gated. If any of the debug_urls of this
+///         debug node is of the grpc:// scheme, when the value of this attribute is set
+///         to True, the data will not actually be sent via the grpc stream unless this
+///         debug op has been enabled at the debug_url. If all of the debug_urls of this
+///         debug node are of the grpc:// scheme and the debug op is enabled at none of
+///         them, the output will be an empty Tensor.
+///
+/// - Output output: A double tensor of shape [14 + nDimensions], where nDimensions is the
+///       the number of dimensions of the tensor's shape. The elements of output are:
+///       [0]: is initialized (1.0) or not (0.0).
+///       [1]: total number of elements
+///       [2]: NaN element count
+///       [3]: generalized -inf count: elements <= lower_bound. lower_bound is -inf by
+///         default.
+///       [4]: negative element count (excluding -inf), if lower_bound is the default
+///         -inf. Otherwise, this is the count of elements > lower_bound and < 0.
+///       [5]: zero element count
+///       [6]: positive element count (excluding +inf), if upper_bound is the default
+///         -inf. Otherwise, this is the count of elements < upper_bound and > 0.
+///       [7]: generalized +inf count, elements >= upper_bound. upper_bound is +inf by
+///         default.
+///     Output elements [1:8] are all zero, if the tensor is uninitialized.
+///       [8]: minimum of all non-inf and non-NaN elements.
+///            If uninitialized or no such element exists: +inf.
+///       [9]: maximum of all non-inf and non-NaN elements.
+///            If uninitialized or no such element exists: -inf.
+///       [10]: mean of all non-inf and non-NaN elements.
+///             If uninitialized or no such element exists: NaN.
+///       [11]: variance of all non-inf and non-NaN elements.
+///             If uninitialized or no such element exists: NaN.
+///       [12]: Data type of the tensor encoded as an enum integer. See the DataType
+///             proto for more details.
+///       [13]: Number of dimensions of the tensor (ndims).
+///       [14+]: Sizes of the dimensions.
+@inlinable @inline(__always)
+public static func debugNumericSummary<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    deviceName: String,
+    tensorName: String,
+    debugUrls: [String],
+    lowerBound: Double = -Double.infinity,
+    upperBound: Double = Double.infinity,
+    muteIfHealthy: Bool = false,
+    gatedGrpc: Bool = false
+) -> Tensor<Double> {
+  let nOutputs = Int(1)
+    let op = makeOp("DebugNumericSummary", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("device_name", deviceName)
+    op.updateAttribute("tensor_name", tensorName)
+    op.updateAttribute("debug_urls", debugUrls)
+    op.updateAttribute("lower_bound", lowerBound)
+    op.updateAttribute("upper_bound", upperBound)
+    op.updateAttribute("mute_if_healthy", muteIfHealthy)
+    op.updateAttribute("gated_grpc", gatedGrpc)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Decode and Crop a JPEG-encoded image to a uint8 tensor.
+///
+/// The attr `channels` indicates the desired number of color channels for the
+/// decoded image.
+///
+/// Accepted values are:
+///
+/// *   0: Use the number of channels in the JPEG-encoded image.
+/// *   1: output a grayscale image.
+/// *   3: output an RGB image.
+///
+/// If needed, the JPEG-encoded image is transformed to match the requested number
+/// of color channels.
+///
+/// The attr `ratio` allows downscaling the image by an integer factor during
+/// decoding.  Allowed values are: 1, 2, 4, and 8.  This is much faster than
+/// downscaling the image later.
+///
+///
+/// It is equivalent to a combination of decode and crop, but much faster by only
+/// decoding partial jpeg image.
+///
+/// - Parameters:
+///     - contents: 0-D.  The JPEG-encoded image.
+///     - crop_window: 1-D.  The crop window: [crop_y, crop_x, crop_height, crop_width].
+///
+/// - Attrs:
+///     - channels: Number of color channels for the decoded image.
+///     - ratio: Downscaling ratio.
+///     - fancy_upscaling: If true use a slower but nicer upscaling of the
+///         chroma planes (yuv420/422 only).
+///     - try_recover_truncated: If true try to recover an image from truncated input.
+///     - acceptable_fraction: The minimum required fraction of lines before a truncated
+///         input is accepted.
+///     - dct_method: string specifying a hint about the algorithm used for
+///         decompression.  Defaults to "" which maps to a system-specific
+///         default.  Currently valid values are ["INTEGER_FAST",
+///         "INTEGER_ACCURATE"].  The hint may be ignored (e.g., the internal
+///         jpeg library changes to a version that does not have that specific
+///         option.)
+///
+/// - Output image: 3-D with shape `[height, width, channels]`..
+@inlinable @inline(__always)
+public static func decodeAndCropJpeg(
+    contents: StringTensor,
+    cropWindow: Tensor<Int32>,
+    channels: Int64 = 0,
+    ratio: Int64 = 1,
+    fancyUpscaling: Bool = true,
+    tryRecoverTruncated: Bool = false,
+    acceptableFraction: Double = 1,
+    dctMethod: String
+) -> Tensor<UInt8> {
+  let nOutputs = Int(1)
+    let op = makeOp("DecodeAndCropJpeg", nOutputs)
+    op.updateAttribute("channels", channels)
+    op.updateAttribute("ratio", ratio)
+    op.updateAttribute("fancy_upscaling", fancyUpscaling)
+    op.updateAttribute("try_recover_truncated", tryRecoverTruncated)
+    op.updateAttribute("acceptable_fraction", acceptableFraction)
+    op.updateAttribute("dct_method", dctMethod)
+    op.addInput(contents)
+    op.addInput(cropWindow)
+    return op.execute(Int(1))
+}
+
+/// Decode web-safe base64-encoded strings.
+///
+/// Input may or may not have padding at the end. See EncodeBase64 for padding.
+/// Web-safe means that input must use - and _ instead of + and /.
+///
+/// - Parameter input: Base64 strings to decode.
+///
+/// - Output output: Decoded strings.
+@inlinable @inline(__always)
+public static func decodeBase64(
+    _ input: StringTensor
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("DecodeBase64", nOutputs)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Decode the first frame of a BMP-encoded image to a uint8 tensor.
+///
+/// The attr `channels` indicates the desired number of color channels for the
+/// decoded image.
+///
+/// Accepted values are:
+///
+/// *   0: Use the number of channels in the BMP-encoded image.
+/// *   3: output an RGB image.
+/// *   4: output an RGBA image.
+///
+/// - Parameter contents: 0-D.  The BMP-encoded image.
+///
+/// - Output image: 3-D with shape `[height, width, channels]`. RGB order
+@inlinable @inline(__always)
+public static func decodeBmp(
+    contents: StringTensor,
+    channels: Int64 = 0
+) -> Tensor<UInt8> {
+  let nOutputs = Int(1)
+    let op = makeOp("DecodeBmp", nOutputs)
+    op.updateAttribute("channels", channels)
+    op.addInput(contents)
+    return op.execute(Int(1))
+}
+
+/// Convert CSV records to tensors. Each column maps to one tensor.
+///
+/// RFC 4180 format is expected for the CSV records.
+/// (https://tools.ietf.org/html/rfc4180)
+/// Note that we allow leading and trailing spaces with int or float field.
+///
+/// - Parameters:
+///     - records: Each string is a record/row in the csv and all records should have
+///         the same format.
+///     - record_defaults: One tensor per column of the input record, with either a
+///         scalar default value for that column or an empty vector if the column is
+///         required.
+///
+/// - Attrs:
+///     - field_delim: char delimiter to separate fields in a record.
+///     - use_quote_delim: If false, treats double quotation marks as regular
+///         characters inside of the string fields (ignoring RFC 4180, Section 2,
+///         Bullet 5).
+///     - na_value: Additional string to recognize as NA/NaN.
+///
+/// - Output output: Each tensor will have the same shape as records.
+@inlinable @inline(__always)
+public static func decodeCSV<OutType: TensorArrayProtocol>(
+    records: StringTensor,
+    recordDefaults: OutType,
+    fieldDelim: String = ",",
+    useQuoteDelim: Bool = true,
+    naValue: String,
+    selectCols: [Int32]
+) -> OutType {
+  let nOutputs = Int(recordDefaults._typeList.count)
+    let op = makeOp("DecodeCSV", nOutputs)
+    op.updateAttribute("OUT_TYPE", recordDefaults._typeList)
+    op.updateAttribute("field_delim", fieldDelim)
+    op.updateAttribute("use_quote_delim", useQuoteDelim)
+    op.updateAttribute("na_value", naValue)
+    op.updateAttribute("select_cols", selectCols)
+    op.addInput(records)
+    op.addInputList(recordDefaults)
+    return op.execute(Int(recordDefaults._typeList.count))
+}
+
+/// Decompress strings.
+///
+/// This op decompresses each element of the `bytes` input `Tensor`, which
+/// is assumed to be compressed using the given `compression_type`.
+///
+/// The `output` is a string `Tensor` of the same shape as `bytes`,
+/// each element containing the decompressed data from the corresponding
+/// element in `bytes`.
+///
+/// - Parameter bytes: A Tensor of string which is compressed.
+///
+/// - Attr compression_type: A scalar containing either (i) the empty string (no
+///     compression), (ii) "ZLIB", or (iii) "GZIP".
+///
+/// - Output output: A Tensor with the same shape as input `bytes`, uncompressed
+///     from bytes.
+@inlinable @inline(__always)
+public static func decodeCompressed(
+    bytes: StringTensor,
+    compressionType: String
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("DecodeCompressed", nOutputs)
+    op.updateAttribute("compression_type", compressionType)
+    op.addInput(bytes)
+    return op.execute(Int(1))
+}
+
+/// Decode the frame(s) of a GIF-encoded image to a uint8 tensor.
+///
+/// GIF images with frame or transparency compression are not supported.
+/// On Linux and MacOS systems, convert animated GIFs from compressed to
+/// uncompressed by running:
+///
+///     convert $src.gif -coalesce $dst.gif
+///
+/// This op also supports decoding JPEGs and PNGs, though it is cleaner to use
+/// `tf.image.decode_image`.
+///
+/// - Parameter contents: 0-D.  The GIF-encoded image.
+///
+/// - Output image: 4-D with shape `[num_frames, height, width, 3]`. RGB channel order.
+@inlinable @inline(__always)
+public static func decodeGif(
+    contents: StringTensor
+) -> Tensor<UInt8> {
+  let nOutputs = Int(1)
+    let op = makeOp("DecodeGif", nOutputs)
+    op.addInput(contents)
+    return op.execute(Int(1))
+}
+
+/// Convert JSON-encoded Example records to binary protocol buffer strings.
+///
+/// This op translates a tensor containing Example records, encoded using
+/// the [standard JSON
+/// mapping](https://developers.google.com/protocol-buffers/docs/proto3#json),
+/// into a tensor containing the same records encoded as binary protocol
+/// buffers. The resulting tensor can then be fed to any of the other
+/// Example-parsing ops.
+///
+/// - Parameter json_examples: Each string is a JSON object serialized according to the JSON
+///     mapping of the Example proto.
+///
+/// - Output binary_examples: Each string is a binary Example protocol buffer corresponding
+///     to the respective element of `json_examples`.
+@inlinable @inline(__always)
+public static func decodeJSONExample(
+    jsonExamples: StringTensor
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("DecodeJSONExample", nOutputs)
+    op.addInput(jsonExamples)
+    return op.execute(Int(1))
+}
+
+/// Decode a JPEG-encoded image to a uint8 tensor.
+///
+/// The attr `channels` indicates the desired number of color channels for the
+/// decoded image.
+///
+/// Accepted values are:
+///
+/// *   0: Use the number of channels in the JPEG-encoded image.
+/// *   1: output a grayscale image.
+/// *   3: output an RGB image.
+///
+/// If needed, the JPEG-encoded image is transformed to match the requested number
+/// of color channels.
+///
+/// The attr `ratio` allows downscaling the image by an integer factor during
+/// decoding.  Allowed values are: 1, 2, 4, and 8.  This is much faster than
+/// downscaling the image later.
+///
+///
+/// This op also supports decoding PNGs and non-animated GIFs since the interface is
+/// the same, though it is cleaner to use `tf.image.decode_image`.
+///
+/// - Parameter contents: 0-D.  The JPEG-encoded image.
+///
+/// - Attrs:
+///     - channels: Number of color channels for the decoded image.
+///     - ratio: Downscaling ratio.
+///     - fancy_upscaling: If true use a slower but nicer upscaling of the
+///         chroma planes (yuv420/422 only).
+///     - try_recover_truncated: If true try to recover an image from truncated input.
+///     - acceptable_fraction: The minimum required fraction of lines before a truncated
+///         input is accepted.
+///     - dct_method: string specifying a hint about the algorithm used for
+///         decompression.  Defaults to "" which maps to a system-specific
+///         default.  Currently valid values are ["INTEGER_FAST",
+///         "INTEGER_ACCURATE"].  The hint may be ignored (e.g., the internal
+///         jpeg library changes to a version that does not have that specific
+///         option.)
+///
+/// - Output image: 3-D with shape `[height, width, channels]`..
+@inlinable @inline(__always)
+public static func decodeJpeg(
+    contents: StringTensor,
+    channels: Int64 = 0,
+    ratio: Int64 = 1,
+    fancyUpscaling: Bool = true,
+    tryRecoverTruncated: Bool = false,
+    acceptableFraction: Double = 1,
+    dctMethod: String
+) -> Tensor<UInt8> {
+  let nOutputs = Int(1)
+    let op = makeOp("DecodeJpeg", nOutputs)
+    op.updateAttribute("channels", channels)
+    op.updateAttribute("ratio", ratio)
+    op.updateAttribute("fancy_upscaling", fancyUpscaling)
+    op.updateAttribute("try_recover_truncated", tryRecoverTruncated)
+    op.updateAttribute("acceptable_fraction", acceptableFraction)
+    op.updateAttribute("dct_method", dctMethod)
+    op.addInput(contents)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func decodePaddedRaw<OutType: Numeric & TensorFlowScalar>(
+    inputBytes: StringTensor,
+    fixedLength: Tensor<Int32>,
+    littleEndian: Bool = true
+) -> Tensor<OutType> {
+  let nOutputs = Int(1)
+    let op = makeOp("DecodePaddedRaw", nOutputs)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("little_endian", littleEndian)
+    op.addInput(inputBytes)
+    op.addInput(fixedLength)
+    return op.execute(Int(1))
+}
+
+/// Decode a PNG-encoded image to a uint8 or uint16 tensor.
+///
+/// The attr `channels` indicates the desired number of color channels for the
+/// decoded image.
+///
+/// Accepted values are:
+///
+/// *   0: Use the number of channels in the PNG-encoded image.
+/// *   1: output a grayscale image.
+/// *   3: output an RGB image.
+/// *   4: output an RGBA image.
+///
+/// If needed, the PNG-encoded image is transformed to match the requested number
+/// of color channels.
+///
+/// This op also supports decoding JPEGs and non-animated GIFs since the interface
+/// is the same, though it is cleaner to use `tf.image.decode_image`.
+///
+/// - Parameter contents: 0-D.  The PNG-encoded image.
+///
+/// - Attr channels: Number of color channels for the decoded image.
+///
+/// - Output image: 3-D with shape `[height, width, channels]`.
+@inlinable @inline(__always)
+public static func decodePng<Dtype: UnsignedInteger & TensorFlowScalar>(
+    contents: StringTensor,
+    channels: Int64 = 0
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("DecodePng", nOutputs)
+    op.updateAttribute("channels", channels)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(contents)
+    return op.execute(Int(1))
+}
+
+/// The op extracts fields from a serialized protocol buffers message into tensors.
+///
+/// The `decode_proto` op extracts fields from a serialized protocol buffers
+/// message into tensors.  The fields in `field_names` are decoded and converted
+/// to the corresponding `output_types` if possible.
+///
+/// A `message_type` name must be provided to give context for the field
+/// names. The actual message descriptor can be looked up either in the
+/// linked-in descriptor pool or a filename provided by the caller using
+/// the `descriptor_source` attribute.
+///
+/// Each output tensor is a dense tensor. This means that it is padded to
+/// hold the largest number of repeated elements seen in the input
+/// minibatch. (The shape is also padded by one to prevent zero-sized
+/// dimensions). The actual repeat counts for each example in the
+/// minibatch can be found in the `sizes` output. In many cases the output
+/// of `decode_proto` is fed immediately into tf.squeeze if missing values
+/// are not a concern. When using tf.squeeze, always pass the squeeze
+/// dimension explicitly to avoid surprises.
+///
+/// For the most part, the mapping between Proto field types and
+/// TensorFlow dtypes is straightforward. However, there are a few
+/// special cases:
+///
+/// - A proto field that contains a submessage or group can only be converted
+/// to `DT_STRING` (the serialized submessage). This is to reduce the
+/// complexity of the API. The resulting string can be used as input
+/// to another instance of the decode_proto op.
+///
+/// - TensorFlow lacks support for unsigned integers. The ops represent uint64
+/// types as a `DT_INT64` with the same twos-complement bit pattern
+/// (the obvious way). Unsigned int32 values can be represented exactly by
+/// specifying type `DT_INT64`, or using twos-complement if the caller
+/// specifies `DT_INT32` in the `output_types` attribute.
+///
+/// The `descriptor_source` attribute selects a source of protocol
+/// descriptors to consult when looking up `message_type`. This may be a
+/// filename containing a serialized `FileDescriptorSet` message,
+/// or the special value `local://`, in which case only descriptors linked
+/// into the code will be searched; the filename can be on any filesystem
+/// accessible to TensorFlow.
+///
+/// You can build a `descriptor_source` file using the `--descriptor_set_out`
+/// and `--include_imports` options to the protocol compiler `protoc`.
+///
+/// The `local://` database only covers descriptors linked into the
+/// code via C++ libraries, not Python imports. You can link in a proto descriptor
+/// by creating a cc_library target with alwayslink=1.
+///
+/// Both binary and text proto serializations are supported, and can be
+/// chosen using the `format` attribute.
+///
+/// - Parameter bytes: Tensor of serialized protos with shape `batch_shape`.
+///
+/// - Attrs:
+///     - message_type: Name of the proto message type to decode.
+///     - field_names: List of strings containing proto field names. An extension field can be decoded
+///         by using its full name, e.g. EXT_PACKAGE.EXT_FIELD_NAME.
+///     - output_types: List of TF types to use for the respective field in field_names.
+///     - descriptor_source: Either the special value `local://` or a path to a file containing
+///         a serialized `FileDescriptorSet`.
+///     - message_format: Either `binary` or `text`.
+///     - sanitize: Whether to sanitize the result or not.
+///
+/// - Outputs:
+///     - sizes: Tensor of int32 with shape `[batch_shape, len(field_names)]`.
+///         Each entry is the number of values found for the corresponding field.
+///         Optional fields may have 0 or 1 values.
+///     - values: List of tensors containing values for the corresponding field.
+///         `values[i]` has datatype `output_types[i]`
+///         and shape `[batch_shape, max(sizes[...,i])]`.
+@inlinable @inline(__always)
+public static func decodeProtoV2<OutputTypes: TensorGroup>(
+    bytes: StringTensor,
+    messageType: String,
+    fieldNames: [String],
+    descriptorSource: String = "local://",
+    messageFormat: String = "binary",
+    sanitize: Bool = false
+) -> (sizes: Tensor<Int32>, values: OutputTypes) {
+  let nOutputs = Int(1) + Int(OutputTypes._typeList.count)
+    let op = makeOp("DecodeProtoV2", nOutputs)
+    op.updateAttribute("message_type", messageType)
+    op.updateAttribute("field_names", fieldNames)
+    op.updateAttribute("output_types", OutputTypes._typeList)
+    op.updateAttribute("descriptor_source", descriptorSource)
+    op.updateAttribute("message_format", messageFormat)
+    op.updateAttribute("sanitize", sanitize)
+    op.addInput(bytes)
+    return op.execute(Int(1), Int(OutputTypes._typeList.count))
+}
+
+/// Reinterpret the bytes of a string as a vector of numbers.
+///
+/// - Parameter bytes: All the elements must have the same length.
+///
+/// - Attr little_endian: Whether the input `bytes` are in little-endian order.
+///     Ignored for `out_type` values that are stored in a single byte like
+///     `uint8`.
+///
+/// - Output output: A Tensor with one more dimension than the input `bytes`.  The
+///     added dimension will have size equal to the length of the elements
+///     of `bytes` divided by the number of bytes to represent `out_type`.
+@inlinable @inline(__always)
+public static func decodeRaw<OutType: TensorFlowScalar>(
+    bytes: StringTensor,
+    littleEndian: Bool = true
+) -> Tensor<OutType> {
+  let nOutputs = Int(1)
+    let op = makeOp("DecodeRaw", nOutputs)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("little_endian", littleEndian)
+    op.addInput(bytes)
+    return op.execute(Int(1))
+}
+
+/// Decode a 16-bit PCM WAV file to a float tensor.
+///
+/// The -32768 to 32767 signed 16-bit values will be scaled to -1.0 to 1.0 in float.
+///
+/// When desired_channels is set, if the input contains fewer channels than this
+/// then the last channel will be duplicated to give the requested number, else if
+/// the input has more channels than requested then the additional channels will be
+/// ignored.
+///
+/// If desired_samples is set, then the audio will be cropped or padded with zeroes
+/// to the requested length.
+///
+/// The first output contains a Tensor with the content of the audio samples. The
+/// lowest dimension will be the number of channels, and the second will be the
+/// number of samples. For example, a ten-sample-long stereo WAV file should give an
+/// output shape of [10, 2].
+///
+/// - Parameter contents: The WAV-encoded audio, usually from a file.
+///
+/// - Attrs:
+///     - desired_channels: Number of sample channels wanted.
+///     - desired_samples: Length of audio requested.
+///
+/// - Outputs:
+///     - audio: 2-D with shape `[length, channels]`.
+///     - sample_rate: Scalar holding the sample rate found in the WAV header.
+@inlinable @inline(__always)
+public static func decodeWav(
+    contents: StringTensor,
+    desiredChannels: Int64 = -1,
+    desiredSamples: Int64 = -1
+) -> (audio: Tensor<Float>, sampleRate: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("DecodeWav", nOutputs)
+    op.updateAttribute("desired_channels", desiredChannels)
+    op.updateAttribute("desired_samples", desiredSamples)
+    op.addInput(contents)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Makes a copy of `x`.
+///
+/// - Parameter x: The source tensor of type `T`.
+///
+/// - Output y:     y: A `Tensor` of type `T`. A copy of `x`. Guaranteed that `y`
+///           is not an alias of `x`.
+@inlinable @inline(__always)
+public static func deepCopy<T: TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DeepCopy", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// A container for an iterator resource.
+///
+/// - Parameters:
+///     - handle: A handle to the iterator to delete.
+///     - deleter: A variant deleter.
+@inlinable @inline(__always)
+public static func deleteIterator(
+    handle: ResourceHandle,
+    deleter: VariantHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("DeleteIterator", nOutputs)
+    op.addInput(handle)
+    op.addInput(deleter)
+    op.execute()
+}
+
+/// Delete the tensor specified by its handle in the session.
+///
+/// - Parameter handle: The handle for a tensor stored in the session state.
+@inlinable @inline(__always)
+public static func deleteSessionTensor(
+    handle: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("DeleteSessionTensor", nOutputs)
+    op.addInput(handle)
+    op.execute()
+}
+
+/// Applies set operation along last dimension of 2 `Tensor` inputs.
+///
+/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+///
+/// Output `result` is a `SparseTensor` represented by `result_indices`,
+/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+/// dimension contains the result of `set_operation` applied to the corresponding
+/// `[0...n-1]` dimension of `set`.
+///
+/// - Parameters:
+///     - set1: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
+///         Dimension `n` contains values in a set, duplicates are allowed but ignored.
+///     - set2: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set1`.
+///         Dimension `n` contains values in a set, duplicates are allowed but ignored.
+///
+/// - Outputs:
+///     - result_indices: 2D indices of a `SparseTensor`.
+///     - result_values: 1D values of a `SparseTensor`.
+///     - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+///         the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+///         is the max result set size across all `0...n-1` dimensions.
+@inlinable @inline(__always)
+public static func denseToDenseSetOperation<T: BinaryInteger & TensorFlowScalar>(
+    set1: Tensor<T>,
+    set2: Tensor<T>,
+    setOperation: String,
+    validateIndices: Bool = true
+) -> (resultIndices: Tensor<Int64>, resultValues: Tensor<T>, resultShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("DenseToDenseSetOperation", nOutputs)
+    op.updateAttribute("set_operation", setOperation)
+    op.updateAttribute("validate_indices", validateIndices)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(set1)
+    op.addInput(set2)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Applies set operation along last dimension of 2 `Tensor` inputs.
+///
+/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+///
+/// Output `result` is a `SparseTensor` represented by `result_indices`,
+/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+/// dimension contains the result of `set_operation` applied to the corresponding
+/// `[0...n-1]` dimension of `set`.
+///
+/// - Parameters:
+///     - set1: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
+///         Dimension `n` contains values in a set, duplicates are allowed but ignored.
+///     - set2: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set1`.
+///         Dimension `n` contains values in a set, duplicates are allowed but ignored.
+///
+/// - Outputs:
+///     - result_indices: 2D indices of a `SparseTensor`.
+///     - result_values: 1D values of a `SparseTensor`.
+///     - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+///         the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+///         is the max result set size across all `0...n-1` dimensions.
+@inlinable @inline(__always)
+public static func denseToDenseSetOperation(
+    set1: StringTensor,
+    set2: StringTensor,
+    setOperation: String,
+    validateIndices: Bool = true
+) -> (resultIndices: Tensor<Int64>, resultValues: StringTensor, resultShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("DenseToDenseSetOperation", nOutputs)
+    op.updateAttribute("set_operation", setOperation)
+    op.updateAttribute("validate_indices", validateIndices)
+    op.updateAttribute("T", TensorDataType(TF_STRING))
+    op.addInput(set1)
+    op.addInput(set2)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Applies set operation along last dimension of `Tensor` and `SparseTensor`.
+///
+/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+///
+/// Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
+/// and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
+/// as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
+/// ignored.
+///
+/// If `validate_indices` is `True`, this op validates the order and range of `set2`
+/// indices.
+///
+/// Output `result` is a `SparseTensor` represented by `result_indices`,
+/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+/// dimension contains the result of `set_operation` applied to the corresponding
+/// `[0...n-1]` dimension of `set`.
+///
+/// - Parameters:
+///     - set1: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
+///         Dimension `n` contains values in a set, duplicates are allowed but ignored.
+///     - set2_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+///         order.
+///     - set2_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+///         order.
+///     - set2_shape: 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
+///         be the same as the 1st `n-1` dimensions of `set1`, `result_shape[n]` is the
+///         max set size across `n-1` dimensions.
+///
+/// - Outputs:
+///     - result_indices: 2D indices of a `SparseTensor`.
+///     - result_values: 1D values of a `SparseTensor`.
+///     - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+///         the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+///         is the max result set size across all `0...n-1` dimensions.
+@inlinable @inline(__always)
+public static func denseToSparseSetOperation<T: BinaryInteger & TensorFlowScalar>(
+    set1: Tensor<T>,
+    set2Indices: Tensor<Int64>,
+    set2Values: Tensor<T>,
+    set2Shape: Tensor<Int64>,
+    setOperation: String,
+    validateIndices: Bool = true
+) -> (resultIndices: Tensor<Int64>, resultValues: Tensor<T>, resultShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("DenseToSparseSetOperation", nOutputs)
+    op.updateAttribute("set_operation", setOperation)
+    op.updateAttribute("validate_indices", validateIndices)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(set1)
+    op.addInput(set2Indices)
+    op.addInput(set2Values)
+    op.addInput(set2Shape)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Applies set operation along last dimension of `Tensor` and `SparseTensor`.
+///
+/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+///
+/// Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
+/// and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
+/// as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
+/// ignored.
+///
+/// If `validate_indices` is `True`, this op validates the order and range of `set2`
+/// indices.
+///
+/// Output `result` is a `SparseTensor` represented by `result_indices`,
+/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+/// dimension contains the result of `set_operation` applied to the corresponding
+/// `[0...n-1]` dimension of `set`.
+///
+/// - Parameters:
+///     - set1: `Tensor` with rank `n`. 1st `n-1` dimensions must be the same as `set2`.
+///         Dimension `n` contains values in a set, duplicates are allowed but ignored.
+///     - set2_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+///         order.
+///     - set2_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+///         order.
+///     - set2_shape: 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
+///         be the same as the 1st `n-1` dimensions of `set1`, `result_shape[n]` is the
+///         max set size across `n-1` dimensions.
+///
+/// - Outputs:
+///     - result_indices: 2D indices of a `SparseTensor`.
+///     - result_values: 1D values of a `SparseTensor`.
+///     - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+///         the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+///         is the max result set size across all `0...n-1` dimensions.
+@inlinable @inline(__always)
+public static func denseToSparseSetOperation(
+    set1: StringTensor,
+    set2Indices: Tensor<Int64>,
+    set2Values: StringTensor,
+    set2Shape: Tensor<Int64>,
+    setOperation: String,
+    validateIndices: Bool = true
+) -> (resultIndices: Tensor<Int64>, resultValues: StringTensor, resultShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("DenseToSparseSetOperation", nOutputs)
+    op.updateAttribute("set_operation", setOperation)
+    op.updateAttribute("validate_indices", validateIndices)
+    op.updateAttribute("T", TensorDataType(TF_STRING))
+    op.addInput(set1)
+    op.addInput(set2Indices)
+    op.addInput(set2Values)
+    op.addInput(set2Shape)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// DepthToSpace for tensors of type T.
+///
+/// Rearranges data from depth into blocks of spatial data.
+/// This is the reverse transformation of SpaceToDepth. More specifically,
+/// this op outputs a copy of the input tensor where values from the `depth`
+/// dimension are moved in spatial blocks to the `height` and `width` dimensions.
+/// The attr `block_size` indicates the input block size and how the data is moved.
+///
+///   * Chunks of data of size `block_size * block_size` from depth are rearranged
+///     into non-overlapping blocks of size `block_size x block_size`
+///   * The width the output tensor is `input_depth * block_size`, whereas the
+///     height is `input_height * block_size`.
+///   * The Y, X coordinates within each block of the output image are determined
+///     by the high order component of the input channel index.
+///   * The depth of the input tensor must be divisible by
+///     `block_size * block_size`.
+///
+/// The `data_format` attr specifies the layout of the input and output tensors
+/// with the following options:
+///   "NHWC": `[ batch, height, width, channels ]`
+///   "NCHW": `[ batch, channels, height, width ]`
+///   "NCHW_VECT_C":
+///       `qint8 [ batch, channels / 4, height, width, 4 ]`
+///
+/// It is useful to consider the operation as transforming a 6-D Tensor.
+/// e.g. for data_format = NHWC,
+///      Each element in the input tensor can be specified via 6 coordinates,
+///      ordered by decreasing memory layout significance as:
+///      n,iY,iX,bY,bX,oC  (where n=batch index, iX, iY means X or Y coordinates
+///                         within the input image, bX, bY means coordinates
+///                         within the output block, oC means output channels).
+///      The output would be the input transposed to the following layout:
+///      n,iY,bY,iX,bX,oC
+///
+/// This operation is useful for resizing the activations between convolutions
+/// (but keeping all data), e.g. instead of pooling. It is also useful for training
+/// purely convolutional models.
+///
+/// For example, given an input of shape `[1, 1, 1, 4]`, data_format = "NHWC" and
+/// block_size = 2:
+///
+/// ```
+/// x = [[[[1, 2, 3, 4]]]]
+///
+/// ```
+///
+/// This operation will output a tensor of shape `[1, 2, 2, 1]`:
+///
+/// ```
+///    [[[[1], [2]],
+///      [[3], [4]]]]
+/// ```
+///
+/// Here, the input has a batch of 1 and each batch element has shape `[1, 1, 4]`,
+/// the corresponding output will have 2x2 elements and will have a depth of
+/// 1 channel (1 = `4 / (block_size * block_size)`).
+/// The output element shape is `[2, 2, 1]`.
+///
+/// For an input tensor with larger depth, here of shape `[1, 1, 1, 12]`, e.g.
+///
+/// ```
+/// x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
+/// ```
+///
+/// This operation, for block size of 2, will return the following tensor of shape
+/// `[1, 2, 2, 3]`
+///
+/// ```
+///    [[[[1, 2, 3], [4, 5, 6]],
+///      [[7, 8, 9], [10, 11, 12]]]]
+///
+/// ```
+///
+/// Similarly, for the following input of shape `[1 2 2 4]`, and a block size of 2:
+///
+/// ```
+/// x =  [[[[1, 2, 3, 4],
+///        [5, 6, 7, 8]],
+///       [[9, 10, 11, 12],
+///        [13, 14, 15, 16]]]]
+/// ```
+///
+/// the operator will return the following tensor of shape `[1 4 4 1]`:
+///
+/// ```
+/// x = [[[ [1],   [2],  [5],  [6]],
+///       [ [3],   [4],  [7],  [8]],
+///       [ [9],  [10], [13],  [14]],
+///       [ [11], [12], [15],  [16]]]]
+///
+/// ```
+///
+/// - Attr block_size: The size of the spatial block, same as in Space2Depth.
+@inlinable @inline(__always)
+public static func depthToSpace<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    blockSize: Int64,
+    dataFormat: DataFormat4 = .nhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DepthToSpace", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("block_size", blockSize)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Computes a 2-D depthwise convolution given 4-D `input` and `filter` tensors.
+///
+/// Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
+/// and a filter / kernel tensor of shape
+/// `[filter_height, filter_width, in_channels, channel_multiplier]`, containing
+/// `in_channels` convolutional filters of depth 1, `depthwise_conv2d` applies
+/// a different filter to each input channel (expanding from 1 channel to
+/// `channel_multiplier` channels for each), then concatenates the results
+/// together. Thus, the output has `in_channels * channel_multiplier` channels.
+///
+/// ```
+/// for k in 0..in_channels-1
+///   for q in 0..channel_multiplier-1
+///     output[b, i, j, k * channel_multiplier + q] =
+///       sum_{di, dj} input[b, strides[1] * i + di, strides[2] * j + dj, k] *
+///                         filter[di, dj, k, q]
+/// ```
+///
+/// Must have `strides[0] = strides[3] = 1`.  For the most common case of the same
+/// horizontal and vertices strides, `strides = [1, stride, stride, 1]`.
+///
+/// - Attrs:
+///     - strides: 1-D of length 4.  The stride of the sliding window for each dimension
+///         of `input`.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, height, width, channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, channels, height, width].
+///     - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///         `input`. If set to k > 1, there will be k-1 skipped cells between each filter
+///         element on that dimension. The dimension order is determined by the value of
+///         `data_format`, see above for details. Dilations in the batch and depth
+///         dimensions must be 1.
+@inlinable @inline(__always)
+public static func depthwiseConv2dNative<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    filter: Tensor<T>,
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat = .nhwc,
+    dilations: [Int32] = [1, 1, 1, 1]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DepthwiseConv2dNative", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filter)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradients of depthwise convolution with respect to the filter.
+///
+/// - Parameters:
+///     - input: 4-D with shape based on `data_format`.  For example, if
+///         `data_format` is 'NHWC' then `input` is a 4-D `[batch, in_height,
+///         in_width, in_channels]` tensor.
+///     - filter_sizes: An integer vector representing the tensor shape of `filter`,
+///         where `filter` is a 4-D
+///         `[filter_height, filter_width, in_channels, depthwise_multiplier]` tensor.
+///     - out_backprop: 4-D with shape  based on `data_format`.
+///         For example, if `data_format` is 'NHWC' then
+///         out_backprop shape is `[batch, out_height, out_width, out_channels]`.
+///         Gradients w.r.t. the output of the convolution.
+///
+/// - Attrs:
+///     - strides: The stride of the sliding window for each dimension of the input
+///         of the convolution.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, height, width, channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, channels, height, width].
+///     - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///         `input`. If set to k > 1, there will be k-1 skipped cells between each filter
+///         element on that dimension. The dimension order is determined by the value of
+///         `data_format`, see above for details. Dilations in the batch and depth
+///         dimensions must be 1.
+///
+/// - Output output: 4-D with shape
+///     `[filter_height, filter_width, in_channels, out_channels]`.  Gradient w.r.t.
+///     the `filter` input of the convolution.
+@inlinable @inline(__always)
+public static func depthwiseConv2dNativeBackpropFilter<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    filterSizes: Tensor<Int32>,
+    outBackprop: Tensor<T>,
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat = .nhwc,
+    dilations: [Int32] = [1, 1, 1, 1]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DepthwiseConv2dNativeBackpropFilter", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filterSizes)
+    op.addInput(outBackprop)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradients of depthwise convolution with respect to the input.
+///
+/// - Parameters:
+///     - input_sizes: An integer vector representing the shape of `input`, based
+///         on `data_format`.  For example, if `data_format` is 'NHWC' then
+///          `input` is a 4-D `[batch, height, width, channels]` tensor.
+///     - filter: 4-D with shape
+///         `[filter_height, filter_width, in_channels, depthwise_multiplier]`.
+///     - out_backprop: 4-D with shape  based on `data_format`.
+///         For example, if `data_format` is 'NHWC' then
+///         out_backprop shape is `[batch, out_height, out_width, out_channels]`.
+///         Gradients w.r.t. the output of the convolution.
+///
+/// - Attrs:
+///     - strides: The stride of the sliding window for each dimension of the input
+///         of the convolution.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, height, width, channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, channels, height, width].
+///     - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///         `input`. If set to k > 1, there will be k-1 skipped cells between each filter
+///         element on that dimension. The dimension order is determined by the value of
+///         `data_format`, see above for details. Dilations in the batch and depth
+///         dimensions must be 1.
+///
+/// - Output output: 4-D with shape according to `data_format`.  For example, if
+///     `data_format` is 'NHWC', output shape is `[batch, in_height,
+///     in_width, in_channels]`.  Gradient w.r.t. the input of the
+///     convolution.
+@inlinable @inline(__always)
+public static func depthwiseConv2dNativeBackpropInput<T: FloatingPoint & TensorFlowScalar>(
+    inputSizes: Tensor<Int32>,
+    filter: Tensor<T>,
+    outBackprop: Tensor<T>,
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat = .nhwc,
+    dilations: [Int32] = [1, 1, 1, 1]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DepthwiseConv2dNativeBackpropInput", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(inputSizes)
+    op.addInput(filter)
+    op.addInput(outBackprop)
+    return op.execute(Int(1))
+}
+
+/// Dequantize the 'input' tensor into a float Tensor.
+///
+/// [min_range, max_range] are scalar floats that specify the range for
+/// the 'input' data. The 'mode' attribute controls exactly which calculations are
+/// used to convert the float values to their quantized equivalents.
+///
+/// In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:
+///
+/// ```
+/// if T == qint8: in[i] += (range(T) + 1)/ 2.0
+/// out[i] = min_range + (in[i]* (max_range - min_range) / range(T))
+/// ```
+/// here `range(T) = numeric_limits<T>::max() - numeric_limits<T>::min()`
+///
+/// *MIN_COMBINED Mode Example*
+///
+/// If the input comes from a QuantizedRelu6, the output type is
+/// quint8 (range of 0-255) but the possible range of QuantizedRelu6 is
+/// 0-6.  The min_range and max_range values are therefore 0.0 and 6.0.
+/// Dequantize on quint8 will take each value, cast to float, and multiply
+/// by 6 / 255.
+/// Note that if quantizedtype is qint8, the operation will additionally add
+/// each value by 128 prior to casting.
+///
+/// If the mode is 'MIN_FIRST', then this approach is used:
+///
+/// ```c++
+/// num_discrete_values = 1 << (# of bits in T)
+/// range_adjust = num_discrete_values / (num_discrete_values - 1)
+/// range = (range_max - range_min) * range_adjust
+/// range_scale = range / num_discrete_values
+/// const double offset_input = static_cast<double>(input) - lowest_quantized;
+/// result = range_min + ((input - numeric_limits<T>::min()) * range_scale)
+/// ```
+///
+/// *SCALED mode Example*
+///
+/// `SCALED` mode matches the quantization approach used in
+/// `QuantizeAndDequantize{V2|V3}`.
+///
+/// If the mode is `SCALED`, we do not use the full range of the output type,
+/// choosing to elide the lowest possible value for symmetry (e.g., output range is
+/// -127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to
+/// 0.
+///
+/// We first find the range of values in our tensor. The
+/// range we use is always centered on 0, so we find m such that
+/// ```c++
+///   m = max(abs(input_min), abs(input_max))
+/// ```
+///
+/// Our input tensor range is then `[-m, m]`.
+///
+/// Next, we choose our fixed-point quantization buckets, `[min_fixed, max_fixed]`.
+/// If T is signed, this is
+/// ```
+///   num_bits = sizeof(T) * 8
+///   [min_fixed, max_fixed] =
+///       [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]
+/// ```
+///
+/// Otherwise, if T is unsigned, the fixed-point range is
+/// ```
+///   [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]
+/// ```
+///
+/// From this we compute our scaling factor, s:
+/// ```c++
+///   s = (2 * m) / (max_fixed - min_fixed)
+/// ```
+///
+/// Now we can dequantize the elements of our tensor:
+/// ```c++
+/// result = input * s
+/// ```
+///
+/// - Parameters:
+///     - min_range: The minimum scalar value possibly produced for the input.
+///     - max_range: The maximum scalar value possibly produced for the input.
+@inlinable @inline(__always)
+public static func dequantize<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    minRange: Tensor<Float>,
+    maxRange: Tensor<Float>,
+    mode: Mode = .minCombined
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("Dequantize", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("mode", mode.cName)
+    op.addInput(input)
+    op.addInput(minRange)
+    op.addInput(maxRange)
+    return op.execute(Int(1))
+}
+
+/// Converts the given variant tensor to an iterator and stores it in the given resource.
+///
+/// - Parameters:
+///     - resource_handle: A handle to an iterator resource.
+///     - serialized: A variant tensor storing the state of the iterator contained in the
+///         resource.
+@inlinable @inline(__always)
+public static func deserializeIterator(
+    resourceHandle: ResourceHandle,
+    serialized: VariantHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("DeserializeIterator", nOutputs)
+    op.addInput(resourceHandle)
+    op.addInput(serialized)
+    op.execute()
+}
+
+/// Deserialize and concatenate `SparseTensors` from a serialized minibatch.
+///
+/// The input `serialized_sparse` must be a string matrix of shape `[N x 3]` where
+/// `N` is the minibatch size and the rows correspond to packed outputs of
+/// `SerializeSparse`.  The ranks of the original `SparseTensor` objects
+/// must all match.  When the final `SparseTensor` is created, it has rank one
+/// higher than the ranks of the incoming `SparseTensor` objects
+/// (they have been concatenated along a new row dimension).
+///
+/// The output `SparseTensor` object's shape values for all dimensions but the
+/// first are the max across the input `SparseTensor` objects' shape values
+/// for the corresponding dimensions.  Its first shape value is `N`, the minibatch
+/// size.
+///
+/// The input `SparseTensor` objects' indices are assumed ordered in
+/// standard lexicographic order.  If this is not the case, after this
+/// step run `SparseReorder` to restore index ordering.
+///
+/// For example, if the serialized input is a `[2 x 3]` matrix representing two
+/// original `SparseTensor` objects:
+///
+///     index = [ 0]
+///             [10]
+///             [20]
+///     values = [1, 2, 3]
+///     shape = [50]
+///
+/// and
+///
+///     index = [ 2]
+///             [10]
+///     values = [4, 5]
+///     shape = [30]
+///
+/// then the final deserialized `SparseTensor` will be:
+///
+///     index = [0  0]
+///             [0 10]
+///             [0 20]
+///             [1  2]
+///             [1 10]
+///     values = [1, 2, 3, 4, 5]
+///     shape = [2 50]
+///
+/// - Parameter serialized_sparse: 2-D, The `N` serialized `SparseTensor` objects.
+///     Must have 3 columns.
+///
+/// - Attr dtype: The `dtype` of the serialized `SparseTensor` objects.
+@inlinable @inline(__always)
+public static func deserializeManySparse<Dtype: TensorFlowScalar>(
+    serializedSparse: StringTensor
+) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("DeserializeManySparse", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(serializedSparse)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Deserialize `SparseTensor` objects.
+///
+/// The input `serialized_sparse` must have the shape `[?, ?, ..., ?, 3]` where
+/// the last dimension stores serialized `SparseTensor` objects and the other N
+/// dimensions (N >= 0) correspond to a batch. The ranks of the original
+/// `SparseTensor` objects must all match. When the final `SparseTensor` is
+/// created, its rank is the rank of the incoming `SparseTensor` objects plus N;
+/// the sparse tensors have been concatenated along new dimensions, one for each
+/// batch.
+///
+/// The output `SparseTensor` object's shape values for the original dimensions
+/// are the max across the input `SparseTensor` objects' shape values for the
+/// corresponding dimensions. The new dimensions match the size of the batch.
+///
+/// The input `SparseTensor` objects' indices are assumed ordered in
+/// standard lexicographic order.  If this is not the case, after this
+/// step run `SparseReorder` to restore index ordering.
+///
+/// For example, if the serialized input is a `[2 x 3]` matrix representing two
+/// original `SparseTensor` objects:
+///
+///     index = [ 0]
+///             [10]
+///             [20]
+///     values = [1, 2, 3]
+///     shape = [50]
+///
+/// and
+///
+///     index = [ 2]
+///             [10]
+///     values = [4, 5]
+///     shape = [30]
+///
+/// then the final deserialized `SparseTensor` will be:
+///
+///     index = [0  0]
+///             [0 10]
+///             [0 20]
+///             [1  2]
+///             [1 10]
+///     values = [1, 2, 3, 4, 5]
+///     shape = [2 50]
+///
+/// - Parameter serialized_sparse: The serialized `SparseTensor` objects. The last dimension
+///     must have 3 columns.
+///
+/// - Attr dtype: The `dtype` of the serialized `SparseTensor` objects.
+@inlinable @inline(__always)
+public static func deserializeSparse<
+    Dtype: TensorFlowScalar,
+    Tserialized: TensorFlowScalar
+>(
+    serializedSparse: Tensor<Tserialized>
+) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("DeserializeSparse", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("Tserialized", Tserialized.tensorFlowDataType)
+    op.addInput(serializedSparse)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Deserialize `SparseTensor` objects.
+///
+/// The input `serialized_sparse` must have the shape `[?, ?, ..., ?, 3]` where
+/// the last dimension stores serialized `SparseTensor` objects and the other N
+/// dimensions (N >= 0) correspond to a batch. The ranks of the original
+/// `SparseTensor` objects must all match. When the final `SparseTensor` is
+/// created, its rank is the rank of the incoming `SparseTensor` objects plus N;
+/// the sparse tensors have been concatenated along new dimensions, one for each
+/// batch.
+///
+/// The output `SparseTensor` object's shape values for the original dimensions
+/// are the max across the input `SparseTensor` objects' shape values for the
+/// corresponding dimensions. The new dimensions match the size of the batch.
+///
+/// The input `SparseTensor` objects' indices are assumed ordered in
+/// standard lexicographic order.  If this is not the case, after this
+/// step run `SparseReorder` to restore index ordering.
+///
+/// For example, if the serialized input is a `[2 x 3]` matrix representing two
+/// original `SparseTensor` objects:
+///
+///     index = [ 0]
+///             [10]
+///             [20]
+///     values = [1, 2, 3]
+///     shape = [50]
+///
+/// and
+///
+///     index = [ 2]
+///             [10]
+///     values = [4, 5]
+///     shape = [30]
+///
+/// then the final deserialized `SparseTensor` will be:
+///
+///     index = [0  0]
+///             [0 10]
+///             [0 20]
+///             [1  2]
+///             [1 10]
+///     values = [1, 2, 3, 4, 5]
+///     shape = [2 50]
+///
+/// - Parameter serialized_sparse: The serialized `SparseTensor` objects. The last dimension
+///     must have 3 columns.
+///
+/// - Attr dtype: The `dtype` of the serialized `SparseTensor` objects.
+@inlinable @inline(__always)
+public static func deserializeSparse<Dtype: TensorFlowScalar>(
+    serializedSparse: StringTensor
+) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("DeserializeSparse", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("Tserialized", TensorDataType(TF_STRING))
+    op.addInput(serializedSparse)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Deletes the resource specified by the handle.
+///
+/// All subsequent operations using the resource will result in a NotFound
+/// error status.
+///
+/// - Parameter resource: handle to the resource to delete.
+///
+/// - Attr ignore_lookup_error: whether to ignore the error when the resource
+///     doesn't exist.
+@inlinable @inline(__always)
+public static func destroyResourceOp(
+    resource: ResourceHandle,
+    ignoreLookupError: Bool = true
+) {
+  let nOutputs = 0
+    let op = makeOp("DestroyResourceOp", nOutputs)
+    op.updateAttribute("ignore_lookup_error", ignoreLookupError)
+    op.addInput(resource)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func devicePlacementOp(
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("DevicePlacementOp", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+/// Returns a diagonal tensor with a given diagonal values.
+///
+/// Given a `diagonal`, this operation returns a tensor with the `diagonal` and
+/// everything else padded with zeros. The diagonal is computed as follows:
+///
+/// Assume `diagonal` has dimensions [D1,..., Dk], then the output is a tensor of
+/// rank 2k with dimensions [D1,..., Dk, D1,..., Dk] where:
+///
+/// `output[i1,..., ik, i1,..., ik] = diagonal[i1, ..., ik]` and 0 everywhere else.
+///
+/// For example:
+///
+/// ```
+/// # 'diagonal' is [1, 2, 3, 4]
+/// tf.diag(diagonal) ==> [[1, 0, 0, 0]
+///                        [0, 2, 0, 0]
+///                        [0, 0, 3, 0]
+///                        [0, 0, 0, 4]]
+/// ```
+///
+/// - Parameter diagonal: Rank k tensor where k is at most 1.
+@inlinable @inline(__always)
+public static func diag<T: Numeric & TensorFlowScalar>(
+    diagonal: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Diag", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(diagonal)
+    return op.execute(Int(1))
+}
+
+/// Returns the diagonal part of the tensor.
+///
+/// This operation returns a tensor with the `diagonal` part
+/// of the `input`. The `diagonal` part is computed as follows:
+///
+/// Assume `input` has dimensions `[D1,..., Dk, D1,..., Dk]`, then the output is a
+/// tensor of rank `k` with dimensions `[D1,..., Dk]` where:
+///
+/// `diagonal[i1,..., ik] = input[i1, ..., ik, i1,..., ik]`.
+///
+/// For example:
+///
+/// ```
+/// # 'input' is [[1, 0, 0, 0]
+///               [0, 2, 0, 0]
+///               [0, 0, 3, 0]
+///               [0, 0, 0, 4]]
+///
+/// tf.diag_part(input) ==> [1, 2, 3, 4]
+/// ```
+///
+/// - Parameter input: Rank k tensor where k is even and not zero.
+///
+/// - Output diagonal: The extracted diagonal.
+@inlinable @inline(__always)
+public static func diagPart<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DiagPart", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Computes Psi, the derivative of Lgamma (the log of the absolute value of
+///
+/// `Gamma(x)`), element-wise.
+@inlinable @inline(__always)
+public static func digamma<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Digamma", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the grayscale dilation of 4-D `input` and 3-D `filter` tensors.
+///
+/// The `input` tensor has shape `[batch, in_height, in_width, depth]` and the
+/// `filter` tensor has shape `[filter_height, filter_width, depth]`, i.e., each
+/// input channel is processed independently of the others with its own structuring
+/// function. The `output` tensor has shape
+/// `[batch, out_height, out_width, depth]`. The spatial dimensions of the output
+/// tensor depend on the `padding` algorithm. We currently only support the default
+/// "NHWC" `data_format`.
+///
+/// In detail, the grayscale morphological 2-D dilation is the max-sum correlation
+/// (for consistency with `conv2d`, we use unmirrored filters):
+///
+///     output[b, y, x, c] =
+///        max_{dy, dx} input[b,
+///                           strides[1] * y + rates[1] * dy,
+///                           strides[2] * x + rates[2] * dx,
+///                           c] +
+///                     filter[dy, dx, c]
+///
+/// Max-pooling is a special case when the filter has size equal to the pooling
+/// kernel size and contains all zeros.
+///
+/// Note on duality: The dilation of `input` by the `filter` is equal to the
+/// negation of the erosion of `-input` by the reflected `filter`.
+///
+/// - Parameters:
+///     - input: 4-D with shape `[batch, in_height, in_width, depth]`.
+///     - filter: 3-D with shape `[filter_height, filter_width, depth]`.
+///
+/// - Attrs:
+///     - strides: The stride of the sliding window for each dimension of the input
+///         tensor. Must be: `[1, stride_height, stride_width, 1]`.
+///     - rates: The input stride for atrous morphological dilation. Must be:
+///         `[1, rate_height, rate_width, 1]`.
+///     - padding: The type of padding algorithm to use.
+///
+/// - Output output: 4-D with shape `[batch, out_height, out_width, depth]`.
+@inlinable @inline(__always)
+public static func dilation2D<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    filter: Tensor<T>,
+    strides: [Int32],
+    rates: [Int32],
+    padding: Padding
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Dilation2D", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("rates", rates)
+    op.updateAttribute("padding", padding.cName)
+    op.addInput(input)
+    op.addInput(filter)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient of morphological 2-D dilation with respect to the filter.
+///
+/// - Parameters:
+///     - input: 4-D with shape `[batch, in_height, in_width, depth]`.
+///     - filter: 3-D with shape `[filter_height, filter_width, depth]`.
+///     - out_backprop: 4-D with shape `[batch, out_height, out_width, depth]`.
+///
+/// - Attrs:
+///     - strides: 1-D of length 4. The stride of the sliding window for each dimension of
+///         the input tensor. Must be: `[1, stride_height, stride_width, 1]`.
+///     - rates: 1-D of length 4. The input stride for atrous morphological dilation.
+///         Must be: `[1, rate_height, rate_width, 1]`.
+///     - padding: The type of padding algorithm to use.
+///
+/// - Output filter_backprop: 3-D with shape `[filter_height, filter_width, depth]`.
+@inlinable @inline(__always)
+public static func dilation2DBackpropFilter<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    filter: Tensor<T>,
+    outBackprop: Tensor<T>,
+    strides: [Int32],
+    rates: [Int32],
+    padding: Padding
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Dilation2DBackpropFilter", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("rates", rates)
+    op.updateAttribute("padding", padding.cName)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(outBackprop)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient of morphological 2-D dilation with respect to the input.
+///
+/// - Parameters:
+///     - input: 4-D with shape `[batch, in_height, in_width, depth]`.
+///     - filter: 3-D with shape `[filter_height, filter_width, depth]`.
+///     - out_backprop: 4-D with shape `[batch, out_height, out_width, depth]`.
+///
+/// - Attrs:
+///     - strides: 1-D of length 4. The stride of the sliding window for each dimension of
+///         the input tensor. Must be: `[1, stride_height, stride_width, 1]`.
+///     - rates: 1-D of length 4. The input stride for atrous morphological dilation.
+///         Must be: `[1, rate_height, rate_width, 1]`.
+///     - padding: The type of padding algorithm to use.
+///
+/// - Output in_backprop: 4-D with shape `[batch, in_height, in_width, depth]`.
+@inlinable @inline(__always)
+public static func dilation2DBackpropInput<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    filter: Tensor<T>,
+    outBackprop: Tensor<T>,
+    strides: [Int32],
+    rates: [Int32],
+    padding: Padding
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Dilation2DBackpropInput", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("rates", rates)
+    op.updateAttribute("padding", padding.cName)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(outBackprop)
+    return op.execute(Int(1))
+}
+
+/// Returns x / y element-wise.
+///
+/// *NOTE*: `Div` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func div<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Div", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns 0 if the denominator is zero.
+///
+///
+/// *NOTE*: `DivNoNan` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func divNoNan<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DivNoNan", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Draw bounding boxes on a batch of images.
+///
+/// Outputs a copy of `images` but draws on top of the pixels zero or more bounding
+/// boxes specified by the locations in `boxes`. The coordinates of the each
+/// bounding box in `boxes` are encoded as `[y_min, x_min, y_max, x_max]`. The
+/// bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
+/// height of the underlying image.
+///
+/// For example, if an image is 100 x 200 pixels (height x width) and the bounding
+/// box is `[0.1, 0.2, 0.5, 0.9]`, the upper-left and bottom-right coordinates of
+/// the bounding box will be `(40, 10)` to `(180, 50)` (in (x,y) coordinates).
+///
+/// Parts of the bounding box may fall outside the image.
+///
+/// - Parameters:
+///     - images: 4-D with shape `[batch, height, width, depth]`. A batch of images.
+///     - boxes: 3-D with shape `[batch, num_bounding_boxes, 4]` containing bounding
+///         boxes.
+///
+/// - Output output: 4-D with the same shape as `images`. The batch of input images with
+///     bounding boxes drawn on the images.
+@inlinable @inline(__always)
+public static func drawBoundingBoxes<T: FloatingPoint & TensorFlowScalar>(
+    images: Tensor<T>,
+    boxes: Tensor<Float>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DrawBoundingBoxes", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(images)
+    op.addInput(boxes)
+    return op.execute(Int(1))
+}
+
+/// Draw bounding boxes on a batch of images.
+///
+/// Outputs a copy of `images` but draws on top of the pixels zero or more bounding
+/// boxes specified by the locations in `boxes`. The coordinates of the each
+/// bounding box in `boxes` are encoded as `[y_min, x_min, y_max, x_max]`. The
+/// bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
+/// height of the underlying image.
+///
+/// For example, if an image is 100 x 200 pixels (height x width) and the bounding
+/// box is `[0.1, 0.2, 0.5, 0.9]`, the upper-left and bottom-right coordinates of
+/// the bounding box will be `(40, 10)` to `(100, 50)` (in (x,y) coordinates).
+///
+/// Parts of the bounding box may fall outside the image.
+///
+/// - Parameters:
+///     - images: 4-D with shape `[batch, height, width, depth]`. A batch of images.
+///     - boxes: 3-D with shape `[batch, num_bounding_boxes, 4]` containing bounding
+///         boxes.
+///     - colors: 2-D. A list of RGBA colors to cycle through for the boxes.
+///
+/// - Output output: 4-D with the same shape as `images`. The batch of input images with
+///     bounding boxes drawn on the images.
+@inlinable @inline(__always)
+public static func drawBoundingBoxesV2<T: FloatingPoint & TensorFlowScalar>(
+    images: Tensor<T>,
+    boxes: Tensor<Float>,
+    colors: Tensor<Float>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DrawBoundingBoxesV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(images)
+    op.addInput(boxes)
+    op.addInput(colors)
+    return op.execute(Int(1))
+}
+
+/// Partitions `data` into `num_partitions` tensors using indices from `partitions`.
+///
+/// For each index tuple `js` of size `partitions.ndim`, the slice `data[js, ...]`
+/// becomes part of `outputs[partitions[js]]`.  The slices with `partitions[js] = i`
+/// are placed in `outputs[i]` in lexicographic order of `js`, and the first
+/// dimension of `outputs[i]` is the number of entries in `partitions` equal to `i`.
+/// In detail,
+///
+/// ```python
+///     outputs[i].shape = [sum(partitions == i)] + data.shape[partitions.ndim:]
+///
+///     outputs[i] = pack([data[js, ...] for js if partitions[js] == i])
+/// ```
+///
+/// `data.shape` must start with `partitions.shape`.
+///
+/// For example:
+///
+/// ```python
+///     # Scalar partitions.
+///     partitions = 1
+///     num_partitions = 2
+///     data = [10, 20]
+///     outputs[0] = []  # Empty with shape [0, 2]
+///     outputs[1] = [[10, 20]]
+///
+///     # Vector partitions.
+///     partitions = [0, 0, 1, 1, 0]
+///     num_partitions = 2
+///     data = [10, 20, 30, 40, 50]
+///     outputs[0] = [10, 20, 50]
+///     outputs[1] = [30, 40]
+/// ```
+///
+/// See `dynamic_stitch` for an example on how to merge partitions back.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/DynamicPartition.png" alt>
+/// </div>
+///
+/// - Parameter partitions: Any shape.  Indices in the range `[0, num_partitions)`.
+///
+/// - Attr num_partitions: The number of partitions to output.
+@inlinable @inline(__always)
+public static func dynamicPartition<T: TensorFlowScalar>(
+    data: Tensor<T>,
+    partitions: Tensor<Int32>,
+    numPartitions: Int64
+) -> [Tensor<T>] {
+  let nOutputs = Int(numPartitions)
+    let op = makeOp("DynamicPartition", nOutputs)
+    op.updateAttribute("num_partitions", numPartitions)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(partitions)
+    return op.execute(Int(numPartitions))
+}
+
+/// Interleave the values from the `data` tensors into a single tensor.
+///
+/// Builds a merged tensor such that
+///
+/// ```python
+///     merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
+/// ```
+///
+/// For example, if each `indices[m]` is scalar or vector, we have
+///
+/// ```python
+///     # Scalar indices:
+///     merged[indices[m], ...] = data[m][...]
+///
+///     # Vector indices:
+///     merged[indices[m][i], ...] = data[m][i, ...]
+/// ```
+///
+/// Each `data[i].shape` must start with the corresponding `indices[i].shape`,
+/// and the rest of `data[i].shape` must be constant w.r.t. `i`.  That is, we
+/// must have `data[i].shape = indices[i].shape + constant`.  In terms of this
+/// `constant`, the output shape is
+///
+///     merged.shape = [max(indices)] + constant
+///
+/// Values are merged in order, so if an index appears in both `indices[m][i]` and
+/// `indices[n][j]` for `(m,i) < (n,j)` the slice `data[n][j]` will appear in the
+/// merged result. If you do not need this guarantee, ParallelDynamicStitch might
+/// perform better on some devices.
+///
+/// For example:
+///
+/// ```python
+///     indices[0] = 6
+///     indices[1] = [4, 1]
+///     indices[2] = [[5, 2], [0, 3]]
+///     data[0] = [61, 62]
+///     data[1] = [[41, 42], [11, 12]]
+///     data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
+///     merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
+///               [51, 52], [61, 62]]
+/// ```
+///
+/// This method can be used to merge partitions created by `dynamic_partition`
+/// as illustrated on the following example:
+///
+/// ```python
+///     # Apply function (increments x_i) on elements for which a certain condition
+///     # apply (x_i != -1 in this example).
+///     x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
+///     condition_mask=tf.not_equal(x,tf.constant(-1.))
+///     partitioned_data = tf.dynamic_partition(
+///         x, tf.cast(condition_mask, tf.int32) , 2)
+///     partitioned_data[1] = partitioned_data[1] + 1.0
+///     condition_indices = tf.dynamic_partition(
+///         tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
+///     x = tf.dynamic_stitch(condition_indices, partitioned_data)
+///     # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
+///     # unchanged.
+/// ```
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/DynamicStitch.png" alt>
+/// </div>
+@inlinable @inline(__always)
+public static func dynamicStitch<T: TensorFlowScalar>(
+    indices: [Tensor<Int32>],
+    data: [Tensor<T>]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("DynamicStitch", nOutputs)
+    op.updateAttribute("N", indices.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInputList(indices)
+    op.addInputList(data)
+    return op.execute(Int(1))
+}
+
+/// 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.
+@inlinable @inline(__always)
+public static func eagerPyFunc<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup
+>(
+    _ input: Tin,
+    token: String
+) -> Tout {
+  let nOutputs = Int(Tout._typeList.count)
+    let op = makeOp("EagerPyFunc", nOutputs)
+    op.updateAttribute("token", token)
+    op.updateAttribute("Tin", input._typeList)
+    op.updateAttribute("Tout", Tout._typeList)
+    op.addInputList(input)
+    return op.execute(Int(Tout._typeList.count))
+}
+
+/// Computes the (possibly normalized) Levenshtein Edit Distance.
+///
+/// The inputs are variable-length sequences provided by SparseTensors
+///   (hypothesis_indices, hypothesis_values, hypothesis_shape)
+/// and
+///   (truth_indices, truth_values, truth_shape).
+///
+/// The inputs are:
+///
+/// - Parameters:
+///     - hypothesis_indices: The indices of the hypothesis list SparseTensor.
+///         This is an N x R int64 matrix.
+///     - hypothesis_values: The values of the hypothesis list SparseTensor.
+///         This is an N-length vector.
+///     - hypothesis_shape: The shape of the hypothesis list SparseTensor.
+///         This is an R-length vector.
+///     - truth_indices: The indices of the truth list SparseTensor.
+///         This is an M x R int64 matrix.
+///     - truth_values: The values of the truth list SparseTensor.
+///         This is an M-length vector.
+///     - truth_shape: truth indices, vector.
+///
+/// - Attr normalize: boolean (if true, edit distances are normalized by length of truth).
+///
+///     The output is:
+///
+/// - Output output: A dense float tensor with rank R - 1.
+///
+///     For the example input:
+///
+///         // hypothesis represents a 2x1 matrix with variable-length values:
+///         //   (0,0) = ["a"]
+///         //   (1,0) = ["b"]
+///         hypothesis_indices = [[0, 0, 0],
+///                               [1, 0, 0]]
+///         hypothesis_values = ["a", "b"]
+///         hypothesis_shape = [2, 1, 1]
+///
+///         // truth represents a 2x2 matrix with variable-length values:
+///         //   (0,0) = []
+///         //   (0,1) = ["a"]
+///         //   (1,0) = ["b", "c"]
+///         //   (1,1) = ["a"]
+///         truth_indices = [[0, 1, 0],
+///                          [1, 0, 0],
+///                          [1, 0, 1],
+///                          [1, 1, 0]]
+///         truth_values = ["a", "b", "c", "a"]
+///         truth_shape = [2, 2, 2]
+///         normalize = true
+///
+///     The output will be:
+///
+///         // output is a 2x2 matrix with edit distances normalized by truth lengths.
+///         output = [[inf, 1.0],  // (0,0): no truth, (0,1): no hypothesis
+///                   [0.5, 1.0]]  // (1,0): addition, (1,1): no hypothesis
+@inlinable @inline(__always)
+public static func editDistance<T: TensorFlowScalar>(
+    hypothesisIndices: Tensor<Int64>,
+    hypothesisValues: Tensor<T>,
+    hypothesisShape: Tensor<Int64>,
+    truthIndices: Tensor<Int64>,
+    truthValues: Tensor<T>,
+    truthShape: Tensor<Int64>,
+    normalize: Bool = true
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("EditDistance", nOutputs)
+    op.updateAttribute("normalize", normalize)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(hypothesisIndices)
+    op.addInput(hypothesisValues)
+    op.addInput(hypothesisShape)
+    op.addInput(truthIndices)
+    op.addInput(truthValues)
+    op.addInput(truthShape)
+    return op.execute(Int(1))
+}
+
+/// Computes exponential linear: `exp(features) - 1` if < 0, `features` otherwise.
+///
+/// See [Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)
+/// ](http://arxiv.org/abs/1511.07289)
+@inlinable @inline(__always)
+public static func elu<T: FloatingPoint & TensorFlowScalar>(
+    features: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Elu", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(features)
+    return op.execute(Int(1))
+}
+
+/// Computes gradients for the exponential linear (Elu) operation.
+///
+/// - Parameters:
+///     - gradients: The backpropagated gradients to the corresponding Elu operation.
+///     - outputs: The outputs of the corresponding Elu operation.
+///
+/// - Output backprops: The gradients: `gradients * (outputs + 1)` if outputs < 0,
+///     `gradients` otherwise.
+@inlinable @inline(__always)
+public static func eluGrad<T: FloatingPoint & TensorFlowScalar>(
+    gradients: Tensor<T>,
+    outputs: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("EluGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(gradients)
+    op.addInput(outputs)
+    return op.execute(Int(1))
+}
+
+/// Creates a tensor with the given shape.
+///
+/// This operation creates a tensor of `shape` and `dtype`.
+///
+/// - Parameter shape: 1-D. Represents the shape of the output tensor.
+///
+/// - Attr init: If True, initialize the returned tensor with the default value of dtype.  Otherwise, the implementation is free not to initializethe tensor's content.
+///
+/// - Output output: A `Tensor` of type `T`.
+@inlinable @inline(__always)
+public static func empty<Dtype: TensorFlowScalar>(
+    shape: Tensor<Int32>,
+    init_: Bool = false
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("Empty", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("init", init_)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Creates and returns an empty tensor list.
+///
+/// All list elements must be tensors of dtype element_dtype and shape compatible
+/// with element_shape.
+///
+/// handle: an empty tensor list.
+/// element_dtype: the type of elements in the list.
+/// element_shape: a shape compatible with that of elements in the list.
+@inlinable @inline(__always)
+public static func emptyTensorList<ShapeType: BinaryInteger & TensorFlowScalar>(
+    elementShape: Tensor<ShapeType>,
+    maxNumElements: Tensor<Int32>,
+    elementDtype: TensorDataType
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("EmptyTensorList", nOutputs)
+    op.updateAttribute("element_dtype", elementDtype)
+    op.updateAttribute("shape_type", ShapeType.tensorFlowDataType)
+    op.addInput(elementShape)
+    op.addInput(maxNumElements)
+    return op.execute(Int(1))
+}
+
+/// Encode strings into web-safe base64 format.
+///
+/// Refer to the following article for more information on base64 format:
+/// en.wikipedia.org/wiki/Base64. Base64 strings may have padding with '=' at the
+/// end so that the encoded has length multiple of 4. See Padding section of the
+/// link above.
+///
+/// Web-safe means that the encoder uses - and _ instead of + and /.
+///
+/// - Parameter input: Strings to be encoded.
+///
+/// - Attr pad: Bool whether padding is applied at the ends.
+///
+/// - Output output: Input strings encoded in base64.
+@inlinable @inline(__always)
+public static func encodeBase64(
+    _ input: StringTensor,
+    pad: Bool = false
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("EncodeBase64", nOutputs)
+    op.updateAttribute("pad", pad)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// JPEG-encode an image.
+///
+/// `image` is a 3-D uint8 Tensor of shape `[height, width, channels]`.
+///
+/// The attr `format` can be used to override the color format of the encoded
+/// output.  Values can be:
+///
+/// *   `''`: Use a default format based on the number of channels in the image.
+/// *   `grayscale`: Output a grayscale JPEG image.  The `channels` dimension
+///     of `image` must be 1.
+/// *   `rgb`: Output an RGB JPEG image. The `channels` dimension
+///     of `image` must be 3.
+///
+/// If `format` is not specified or is the empty string, a default format is picked
+/// in function of the number of channels in `image`:
+///
+/// *   1: Output a grayscale image.
+/// *   3: Output an RGB image.
+///
+/// - Parameter image: 3-D with shape `[height, width, channels]`.
+///
+/// - Attrs:
+///     - format: Per pixel image format.
+///     - quality: Quality of the compression from 0 to 100 (higher is better and slower).
+///     - progressive: If True, create a JPEG that loads progressively (coarse to fine).
+///     - optimize_size: If True, spend CPU/RAM to reduce size with no quality change.
+///     - chroma_downsampling: See http://en.wikipedia.org/wiki/Chroma_subsampling.
+///     - density_unit: Unit used to specify `x_density` and `y_density`:
+///         pixels per inch (`'in'`) or centimeter (`'cm'`).
+///     - x_density: Horizontal pixels per density unit.
+///     - y_density: Vertical pixels per density unit.
+///     - xmp_metadata: If not empty, embed this XMP metadata in the image header.
+///
+/// - Output contents: 0-D. JPEG-encoded image.
+@inlinable @inline(__always)
+public static func encodeJpeg(
+    image: Tensor<UInt8>,
+    format: Format,
+    quality: Int64 = 95,
+    progressive: Bool = false,
+    optimizeSize: Bool = false,
+    chromaDownsampling: Bool = true,
+    densityUnit: DensityUnit = .in_,
+    xDensity: Int64 = 300,
+    yDensity: Int64 = 300,
+    xmpMetadata: String
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("EncodeJpeg", nOutputs)
+    op.updateAttribute("format", format.cName)
+    op.updateAttribute("quality", quality)
+    op.updateAttribute("progressive", progressive)
+    op.updateAttribute("optimize_size", optimizeSize)
+    op.updateAttribute("chroma_downsampling", chromaDownsampling)
+    op.updateAttribute("density_unit", densityUnit.cName)
+    op.updateAttribute("x_density", xDensity)
+    op.updateAttribute("y_density", yDensity)
+    op.updateAttribute("xmp_metadata", xmpMetadata)
+    op.addInput(image)
+    return op.execute(Int(1))
+}
+
+/// JPEG encode input image with provided compression quality.
+///
+/// `image` is a 3-D uint8 Tensor of shape `[height, width, channels]`.
+/// `quality` is an int32 jpeg compression quality value between 0 and 100.
+///
+///
+/// - Parameters:
+///     - images: Images to adjust.  At least 3-D.
+///     - quality: An int quality to encode to.
+///
+/// - Output contents: 0-D. JPEG-encoded image.
+@inlinable @inline(__always)
+public static func encodeJpegVariableQuality(
+    images: Tensor<UInt8>,
+    quality: Tensor<Int32>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("EncodeJpegVariableQuality", nOutputs)
+    op.addInput(images)
+    op.addInput(quality)
+    return op.execute(Int(1))
+}
+
+/// PNG-encode an image.
+///
+/// `image` is a 3-D uint8 or uint16 Tensor of shape `[height, width, channels]`
+/// where `channels` is:
+///
+/// *   1: for grayscale.
+/// *   2: for grayscale + alpha.
+/// *   3: for RGB.
+/// *   4: for RGBA.
+///
+/// The ZLIB compression level, `compression`, can be -1 for the PNG-encoder
+/// default or a value from 0 to 9.  9 is the highest compression level, generating
+/// the smallest output, but is slower.
+///
+/// - Parameter image: 3-D with shape `[height, width, channels]`.
+///
+/// - Attr compression: Compression level.
+///
+/// - Output contents: 0-D. PNG-encoded image.
+@inlinable @inline(__always)
+public static func encodePng<T: UnsignedInteger & TensorFlowScalar>(
+    image: Tensor<T>,
+    compression: Int64 = -1
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("EncodePng", nOutputs)
+    op.updateAttribute("compression", compression)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(image)
+    return op.execute(Int(1))
+}
+
+/// The op serializes protobuf messages provided in the input tensors.
+///
+/// The types of the tensors in `values` must match the schema for the
+/// fields specified in `field_names`. All the tensors in `values` must
+/// have a common shape prefix, *batch_shape*.
+///
+/// The `sizes` tensor specifies repeat counts for each field.  The repeat
+/// count (last dimension) of a each tensor in `values` must be greater
+/// than or equal to corresponding repeat count in `sizes`.
+///
+/// A `message_type` name must be provided to give context for the field
+/// names. The actual message descriptor can be looked up either in the
+/// linked-in descriptor pool or a filename provided by the caller using
+/// the `descriptor_source` attribute.
+///
+/// The `descriptor_source` attribute selects a source of protocol
+/// descriptors to consult when looking up `message_type`. This may be a
+/// filename containing a serialized `FileDescriptorSet` message,
+/// or the special value `local://`, in which case only descriptors linked
+/// into the code will be searched; the filename can be on any filesystem
+/// accessible to TensorFlow.
+///
+/// You can build a `descriptor_source` file using the `--descriptor_set_out`
+/// and `--include_imports` options to the protocol compiler `protoc`.
+///
+/// The `local://` database only covers descriptors linked into the
+/// code via C++ libraries, not Python imports. You can link in a proto descriptor
+/// by creating a cc_library target with alwayslink=1.
+///
+/// There are a few special cases in the value mapping:
+///
+/// Submessage and group fields must be pre-serialized as TensorFlow strings.
+///
+/// TensorFlow lacks support for unsigned int64s, so they must be
+/// represented as `tf.int64` with the same twos-complement bit pattern
+/// (the obvious way).
+///
+/// Unsigned int32 values can be represented exactly with `tf.int64`, or
+/// with sign wrapping if the input is of type `tf.int32`.
+///
+/// - Parameters:
+///     - sizes: Tensor of int32 with shape `[batch_shape, len(field_names)]`.
+///     - values: List of tensors containing values for the corresponding field.
+///
+/// - Attrs:
+///     - field_names: List of strings containing proto field names.
+///     - message_type: Name of the proto message type to decode.
+///     - Tinput_types: The input types.
+///
+/// - Output bytes: Tensor of serialized protos with shape `batch_shape`.
+@inlinable @inline(__always)
+public static func encodeProto<TinputTypes: TensorArrayProtocol>(
+    sizes: Tensor<Int32>,
+    _ values: TinputTypes,
+    fieldNames: [String],
+    messageType: String,
+    descriptorSource: String = "local://"
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("EncodeProto", nOutputs)
+    op.updateAttribute("field_names", fieldNames)
+    op.updateAttribute("message_type", messageType)
+    op.updateAttribute("descriptor_source", descriptorSource)
+    op.updateAttribute("Tinput_types", values._typeList)
+    op.addInput(sizes)
+    op.addInputList(values)
+    return op.execute(Int(1))
+}
+
+/// Encode audio data using the WAV file format.
+///
+/// This operation will generate a string suitable to be saved out to create a .wav
+/// audio file. It will be encoded in the 16-bit PCM format. It takes in float
+/// values in the range -1.0f to 1.0f, and any outside that value will be clamped to
+/// that range.
+///
+/// `audio` is a 2-D float Tensor of shape `[length, channels]`.
+/// `sample_rate` is a scalar Tensor holding the rate to use (e.g. 44100).
+///
+/// - Parameters:
+///     - audio: 2-D with shape `[length, channels]`.
+///     - sample_rate: Scalar containing the sample frequency.
+///
+/// - Output contents: 0-D. WAV-encoded file contents.
+@inlinable @inline(__always)
+public static func encodeWav(
+    audio: Tensor<Float>,
+    sampleRate: Tensor<Int32>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("EncodeWav", nOutputs)
+    op.addInput(audio)
+    op.addInput(sampleRate)
+    return op.execute(Int(1))
+}
+
+/// An op that enqueues a list of input batch tensors to TPUEmbedding.
+///
+/// - Parameters:
+///     - batch: A list of 1D tensors, one for each embedding table, containing the
+///         indices into the tables.
+///     - mode_override: A string input that overrides the mode specified in the
+///         TPUEmbeddingConfiguration. Supported values are {'unspecified', 'inference',
+///         'training', 'backward_pass_only'}. When set to 'unspecified', the mode set
+///         in TPUEmbeddingConfiguration is used, otherwise mode_override is used.
+///
+/// - Attr device_ordinal: The TPU device to use. Should be >= 0 and less than the number
+///     of TPU cores in the task on which the node is placed.
+@inlinable @inline(__always)
+public static func enqueueTPUEmbeddingIntegerBatch(
+    batch: [Tensor<Int32>],
+    modeOverride: StringTensor,
+    deviceOrdinal: Int64 = -1
+) {
+  let nOutputs = 0
+    let op = makeOp("EnqueueTPUEmbeddingIntegerBatch", nOutputs)
+    op.updateAttribute("N", batch.count)
+    op.updateAttribute("device_ordinal", deviceOrdinal)
+    op.addInputList(batch)
+    op.addInput(modeOverride)
+    op.execute()
+}
+
+/// An op that enqueues TPUEmbedding input indices from a SparseTensor.
+///
+/// This Op eases the porting of code that uses embedding_lookup_sparse(),
+/// although some Python preprocessing of the SparseTensor arguments to
+/// embedding_lookup_sparse() is required to produce the arguments to this Op,
+/// since only a single EnqueueTPUEmbeddingSparseBatch Op is allowed per training
+/// step.
+///
+/// The tensors at corresponding positions in the three input lists
+/// must have the same shape, i.e. rank 1 with dim_size() equal to the total
+/// number of lookups into the table described by the corresponding table_id.
+///
+/// - Parameters:
+///     - sample_indices: A list of rank 1 Tensors specifying the training example and
+///         feature to which the corresponding embedding_indices and aggregation_weights
+///         values belong. sample_indices[i] must equal b * nf + f, where nf is the
+///         number of features from the corresponding table, f is in [0, nf), and
+///         b is in [0, batch size).
+///     - embedding_indices: A list of rank 1 Tensors, indices into the embedding tables.
+///     - aggregation_weights: A list of rank 1 Tensors containing per sample -- i.e. per
+///         (training example, feature) -- aggregation weights.
+///     - mode_override: A string input that overrides the mode specified in the
+///         TPUEmbeddingConfiguration. Supported values are {'unspecified', 'inference',
+///         'training', 'backward_pass_only'}. When set to 'unspecified', the mode set
+///         in TPUEmbeddingConfiguration is used, otherwise mode_override is used.
+///
+/// - Attrs:
+///     - device_ordinal: The TPU device to use. Should be >= 0 and less than the number
+///         of TPU cores in the task on which the node is placed.
+///     - combiners: A list of string scalars, one for each embedding table that specify
+///         how to normalize the embedding activations after weighted summation.
+///         Supported combiners are 'mean', 'sum', or 'sqrtn'. It is invalid to have
+///         the sum of the weights be 0 for 'mean' or the sum of the squared weights be
+///         0 for 'sqrtn'. If combiners isn't passed, the default is to use 'sum' for
+///         all tables.
+@inlinable @inline(__always)
+public static func enqueueTPUEmbeddingSparseBatch<
+    T1: BinaryInteger & TensorFlowScalar,
+    T2: BinaryInteger & TensorFlowScalar,
+    T3: FloatingPoint & TensorFlowScalar
+>(
+    sampleIndices: [Tensor<T1>],
+    embeddingIndices: [Tensor<T2>],
+    aggregationWeights: [Tensor<T3>],
+    modeOverride: StringTensor,
+    deviceOrdinal: Int64 = -1,
+    combiners: [String]
+) {
+  let nOutputs = 0
+    let op = makeOp("EnqueueTPUEmbeddingSparseBatch", nOutputs)
+    op.updateAttribute("T1", T1.tensorFlowDataType)
+    op.updateAttribute("T2", T2.tensorFlowDataType)
+    op.updateAttribute("T3", T3.tensorFlowDataType)
+    op.updateAttribute("N", sampleIndices.count)
+    op.updateAttribute("device_ordinal", deviceOrdinal)
+    op.updateAttribute("combiners", combiners)
+    op.addInputList(sampleIndices)
+    op.addInputList(embeddingIndices)
+    op.addInputList(aggregationWeights)
+    op.addInput(modeOverride)
+    op.execute()
+}
+
+/// Eases the porting of code that uses tf.nn.embedding_lookup_sparse().
+///
+/// sample_indices[i], embedding_indices[i] and aggregation_weights[i] correspond
+/// to the ith feature. table_ids[i] indicates which embedding table to look up ith
+/// feature.
+///
+/// The tensors at corresponding positions in the three input lists (sample_indices,
+/// embedding_indices and aggregation_weights) must have the same shape, i.e. rank 1
+/// with dim_size() equal to the total number of lookups into the table described by
+/// the corresponding feature.
+///
+/// - Parameters:
+///     - sample_indices: A list of rank 1 Tensors specifying the training example to
+///         which the corresponding embedding_indices and aggregation_weights values
+///         belong. It corresponds to sp_ids.indices[:,0] in  embedding_lookup_sparse().
+///     - embedding_indices: A list of rank 1 Tensors, indices into the embedding tables.
+///         It corresponds to sp_ids.values in embedding_lookup_sparse().
+///     - aggregation_weights: A list of rank 1 Tensors containing per training example
+///         aggregation weights. It corresponds to sp_weights.values in
+///         embedding_lookup_sparse().
+///     - mode_override: A string input that overrides the mode specified in the
+///         TPUEmbeddingConfiguration. Supported values are {'unspecified', 'inference',
+///         'training', 'backward_pass_only'}. When set to 'unspecified', the mode set
+///         in TPUEmbeddingConfiguration is used, otherwise mode_override is used.
+///
+/// - Attrs:
+///     - device_ordinal: The TPU device to use. Should be >= 0 and less than the number
+///         of TPU cores in the task on which the node is placed.
+///     - combiners: A list of string scalars, one for each embedding table that specify
+///         how to normalize the embedding activations after weighted summation.
+///         Supported combiners are 'mean', 'sum', or 'sqrtn'. It is invalid to have
+///         the sum of the weights be 0 for 'mean' or the sum of the squared weights be
+///         0 for 'sqrtn'. If combiners isn't passed, the default is to use 'sum' for
+///         all tables.
+///     - table_ids: A list of integers specifying the identifier of the embedding table
+///         (offset of TableDescriptor in the TPUEmbeddingConfiguration) to lookup the
+///         corresponding input. The ith input is looked up using table_ids[i]. The size
+///         of the table_ids list must be equal to that of sample_indices,
+///         embedding_indices and aggregation_weights.
+@inlinable @inline(__always)
+public static func enqueueTPUEmbeddingSparseTensorBatch<
+    T1: BinaryInteger & TensorFlowScalar,
+    T2: BinaryInteger & TensorFlowScalar,
+    T3: FloatingPoint & TensorFlowScalar
+>(
+    sampleIndices: [Tensor<T1>],
+    embeddingIndices: [Tensor<T2>],
+    aggregationWeights: [Tensor<T3>],
+    modeOverride: StringTensor,
+    deviceOrdinal: Int64 = -1,
+    combiners: [String],
+    tableIds: [Int32],
+    maxSequenceLengths: [Int32]
+) {
+  let nOutputs = 0
+    let op = makeOp("EnqueueTPUEmbeddingSparseTensorBatch", nOutputs)
+    op.updateAttribute("T1", T1.tensorFlowDataType)
+    op.updateAttribute("T2", T2.tensorFlowDataType)
+    op.updateAttribute("T3", T3.tensorFlowDataType)
+    op.updateAttribute("N", sampleIndices.count)
+    op.updateAttribute("device_ordinal", deviceOrdinal)
+    op.updateAttribute("combiners", combiners)
+    op.updateAttribute("table_ids", tableIds)
+    op.updateAttribute("max_sequence_lengths", maxSequenceLengths)
+    op.addInputList(sampleIndices)
+    op.addInputList(embeddingIndices)
+    op.addInputList(aggregationWeights)
+    op.addInput(modeOverride)
+    op.execute()
+}
+
+/// Ensures that the tensor's shape matches the expected shape.
+///
+/// Raises an error if the input tensor's shape does not match the specified shape.
+/// Returns the input tensor otherwise.
+///
+/// - Parameter input: A tensor, whose shape is to be validated.
+///
+/// - Attr shape: The expected (possibly partially specified) shape of the input tensor.
+///
+/// - Output output: A tensor with the same shape and contents as the input tensor or value.
+@inlinable @inline(__always)
+public static func ensureShape<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    shape: TensorShape?
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("EnsureShape", nOutputs)
+    op.updateAttribute("shape", shape)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Creates or finds a child frame, and makes `data` available to the child frame.
+///
+/// This op is used together with `Exit` to create loops in the graph.
+/// The unique `frame_name` is used by the `Executor` to identify frames. If
+/// `is_constant` is true, `output` is a constant in the child frame; otherwise
+/// it may be changed in the child frame. At most `parallel_iterations` iterations
+/// are run in parallel in the child frame.
+///
+/// - Parameter data: The tensor to be made available to the child frame.
+///
+/// - Attrs:
+///     - frame_name: The name of the child frame.
+///     - is_constant: If true, the output is constant within the child frame.
+///     - parallel_iterations: The number of iterations allowed to run in parallel.
+///
+/// - Output output: The same tensor as `data`.
+@inlinable @inline(__always)
+public static func enter<T: TensorFlowScalar>(
+    data: Tensor<T>,
+    frameName: String,
+    isConstant: Bool = false,
+    parallelIterations: Int64 = 10
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Enter", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("frame_name", frameName)
+    op.updateAttribute("is_constant", isConstant)
+    op.updateAttribute("parallel_iterations", parallelIterations)
+    op.addInput(data)
+    return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x == y) element-wise.
+///
+/// *NOTE*: `Equal` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func equal<T: TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("Equal", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x == y) element-wise.
+///
+/// *NOTE*: `Equal` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func equal(
+    _ x: StringTensor,
+    _ y: StringTensor
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("Equal", nOutputs)
+    op.updateAttribute("T", TensorDataType(TF_STRING))
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Computes the Gauss error function of `x` element-wise.
+@inlinable @inline(__always)
+public static func erf<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Erf", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the complementary error function of `x` element-wise.
+@inlinable @inline(__always)
+public static func erfc<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Erfc", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the euclidean norm of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///     - input: The tensor to reduce.
+///     - reduction_indices: The dimensions to reduce. Must be in the range
+///         `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func euclideanNorm<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    reductionIndices: Tensor<Tidx>,
+    keepDims: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("EuclideanNorm", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(reductionIndices)
+    return op.execute(Int(1))
+}
+
+/// Exits the current frame to its parent frame.
+///
+/// Exit makes its input `data` available to the parent frame.
+///
+/// - Parameter data: The tensor to be made available to the parent frame.
+///
+/// - Output output: The same tensor as `data`.
+@inlinable @inline(__always)
+public static func exit<T: TensorFlowScalar>(
+    data: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Exit", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(data)
+    return op.execute(Int(1))
+}
+
+/// Computes exponential of x element-wise.  \\(y = e^x\\).
+@inlinable @inline(__always)
+public static func exp<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Exp", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Inserts a dimension of 1 into a tensor's shape.
+///
+/// Given a tensor `input`, this operation inserts a dimension of 1 at the
+/// dimension index `axis` of `input`'s shape. The dimension index `axis` starts at
+/// zero; if you specify a negative number for `axis` it is counted backward from
+/// the end.
+///
+/// This operation is useful if you want to add a batch dimension to a single
+/// element. For example, if you have a single image of shape `[height, width,
+/// channels]`, you can make it a batch of 1 image with `expand_dims(image, 0)`,
+/// which will make the shape `[1, height, width, channels]`.
+///
+/// Other examples:
+///
+/// ```
+/// # 't' is a tensor of shape [2]
+/// shape(expand_dims(t, 0)) ==> [1, 2]
+/// shape(expand_dims(t, 1)) ==> [2, 1]
+/// shape(expand_dims(t, -1)) ==> [2, 1]
+///
+/// # 't2' is a tensor of shape [2, 3, 5]
+/// shape(expand_dims(t2, 0)) ==> [1, 2, 3, 5]
+/// shape(expand_dims(t2, 2)) ==> [2, 3, 1, 5]
+/// shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]
+/// ```
+///
+/// This operation requires that:
+///
+/// `-1-input.dims() <= dim <= input.dims()`
+///
+/// This operation is related to `squeeze()`, which removes dimensions of
+/// size 1.
+///
+/// - Parameter dim: 0-D (scalar). Specifies the dimension index at which to
+///     expand the shape of `input`. Must be in the range
+///     `[-rank(input) - 1, rank(input)]`.
+///
+/// - Output output: Contains the same data as `input`, but its shape has an additional
+///     dimension of size 1 added.
+@inlinable @inline(__always)
+public static func expandDims<
+    T: TensorFlowScalar,
+    Tdim: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    dim: Tensor<Tdim>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ExpandDims", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tdim", Tdim.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(dim)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalAssertNextDataset(
+    inputDataset: VariantHandle,
+    transformations: StringTensor,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalAssertNextDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(transformations)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that shards the input dataset.
+///
+/// Creates a dataset that shards the input dataset by num_workers, returning a
+/// sharded dataset for the index-th worker. This attempts to automatically shard
+/// a dataset by examining the Dataset graph and inserting a shard op before the
+/// inputs to a reader Dataset (e.g. CSVDataset, TFRecordDataset).
+///
+/// This dataset will throw a NotFound error if we cannot shard the dataset
+/// automatically.
+///
+/// - Parameters:
+///     - input_dataset: A variant tensor representing the input dataset.
+///     - num_workers: A scalar representing the number of workers to distribute this dataset across.
+///     - index: A scalar representing the index of the current worker out of num_workers.
+@inlinable @inline(__always)
+public static func experimentalAutoShardDataset(
+    inputDataset: VariantHandle,
+    numWorkers: Tensor<Int64>,
+    index: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalAutoShardDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(numWorkers)
+    op.addInput(index)
+    return op.execute(Int(1))
+}
+
+/// Records the bytes size of each element of `input_dataset` in a StatsAggregator.
+@inlinable @inline(__always)
+public static func experimentalBytesProducedStatsDataset(
+    inputDataset: VariantHandle,
+    tag: StringTensor,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalBytesProducedStatsDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(tag)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalCSVDataset<OutputTypes: TensorArrayProtocol>(
+    filenames: StringTensor,
+    compressionType: StringTensor,
+    bufferSize: Tensor<Int64>,
+    header: Tensor<Bool>,
+    fieldDelim: StringTensor,
+    useQuoteDelim: Tensor<Bool>,
+    naValue: StringTensor,
+    selectCols: Tensor<Int64>,
+    recordDefaults: OutputTypes,
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalCSVDataset", nOutputs)
+    op.updateAttribute("output_types", recordDefaults._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(filenames)
+    op.addInput(compressionType)
+    op.addInput(bufferSize)
+    op.addInput(header)
+    op.addInput(fieldDelim)
+    op.addInput(useQuoteDelim)
+    op.addInput(naValue)
+    op.addInput(selectCols)
+    op.addInputList(recordDefaults)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalChooseFastestDataset(
+    inputDatasets: [VariantHandle],
+    numExperiments: Int64,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalChooseFastestDataset", nOutputs)
+    op.updateAttribute("N", inputDatasets.count)
+    op.updateAttribute("num_experiments", numExperiments)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInputList(inputDatasets)
+    return op.execute(Int(1))
+}
+
+/// Returns the cardinality of `input_dataset`.
+///
+/// Returns the cardinality of `input_dataset`.
+///
+/// - Parameter input_dataset: A variant tensor representing the dataset to return cardinality for.
+///
+/// - Output cardinality: The cardinality of `input_dataset`. Named constants are used to represent
+///     infinite and unknown cardinality.
+@inlinable @inline(__always)
+public static func experimentalDatasetCardinality(
+    inputDataset: VariantHandle
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalDatasetCardinality", nOutputs)
+    op.addInput(inputDataset)
+    return op.execute(Int(1))
+}
+
+/// Writes the given dataset to the given file using the TFRecord format.
+///
+/// - Parameters:
+///     - input_dataset: A variant tensor representing the dataset to write.
+///     - filename: A scalar string tensor representing the filename to use.
+///     - compression_type: A scalar string tensor containing either (i) the empty string (no
+///         compression), (ii) "ZLIB", or (iii) "GZIP".
+@inlinable @inline(__always)
+public static func experimentalDatasetToTFRecord(
+    inputDataset: VariantHandle,
+    filename: StringTensor,
+    compressionType: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("ExperimentalDatasetToTFRecord", nOutputs)
+    op.addInput(inputDataset)
+    op.addInput(filename)
+    op.addInput(compressionType)
+    op.execute()
+}
+
+/// Creates a dataset that batches input elements into a SparseTensor.
+///
+/// - Parameters:
+///     - input_dataset: A handle to an input dataset. Must have a single component.
+///     - batch_size: A scalar representing the number of elements to accumulate in a
+///         batch.
+///     - row_shape: A vector representing the dense shape of each row in the produced
+///         SparseTensor. The shape may be partially specified, using `-1` to indicate
+///         that a particular dimension should use the maximum size of all batch elements.
+@inlinable @inline(__always)
+public static func experimentalDenseToSparseBatchDataset(
+    inputDataset: VariantHandle,
+    batchSize: Tensor<Int64>,
+    rowShape: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalDenseToSparseBatchDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(batchSize)
+    op.addInput(rowShape)
+    return op.execute(Int(1))
+}
+
+/// A substitute for `InterleaveDataset` on a fixed list of `N` datasets.
+///
+/// - Parameters:
+///     - selector_input_dataset: A dataset of scalar `DT_INT64` elements that determines which of the
+///         `N` data inputs should produce the next output element.
+///     - data_input_datasets: `N` datasets with the same type that will be interleaved according to
+///         the values of `selector_input_dataset`.
+@inlinable @inline(__always)
+public static func experimentalDirectedInterleaveDataset(
+    selectorInputDataset: VariantHandle,
+    dataInputDatasets: [VariantHandle],
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalDirectedInterleaveDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("N", dataInputDatasets.count)
+    op.addInput(selectorInputDataset)
+    op.addInputList(dataInputDatasets)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that computes a group-by on `input_dataset`.
+///
+/// Creates a dataset that computes a group-by on `input_dataset`.
+///
+/// - Parameters:
+///     - input_dataset: A variant tensor representing the input dataset.
+///     - key_func_other_arguments: A list of tensors, typically values that were captured when
+///         building a closure for `key_func`.
+///     - init_func_other_arguments: A list of tensors, typically values that were captured when
+///         building a closure for `init_func`.
+///     - reduce_func_other_arguments: A list of tensors, typically values that were captured when
+///         building a closure for `reduce_func`.
+///     - finalize_func_other_arguments: A list of tensors, typically values that were captured when
+///         building a closure for `finalize_func`.
+///
+/// - Attrs:
+///     - key_func: A function mapping an element of `input_dataset`, concatenated
+///         with `key_func_other_arguments` to a scalar value of type DT_INT64.
+///     - init_func: A function mapping a key of type DT_INT64, concatenated with
+///         `init_func_other_arguments` to the initial reducer state.
+///     - reduce_func: A function mapping the current reducer state and an element of `input_dataset`,
+///         concatenated with `reduce_func_other_arguments` to a new reducer state.
+///     - finalize_func: A function mapping the final reducer state to an output element.
+@inlinable @inline(__always)
+public static func experimentalGroupByReducerDataset<
+    KeyfuncIn: TensorGroup,
+    KeyfuncOut: TensorGroup,
+    InitfuncIn: TensorGroup,
+    InitfuncOut: TensorGroup,
+    ReducefuncIn: TensorGroup,
+    ReducefuncOut: TensorGroup,
+    FinalizefuncIn: TensorGroup,
+    FinalizefuncOut: TensorGroup,
+    TkeyFuncOtherArguments: TensorArrayProtocol,
+    TinitFuncOtherArguments: TensorArrayProtocol,
+    TreduceFuncOtherArguments: TensorArrayProtocol,
+    TfinalizeFuncOtherArguments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    keyFuncOtherArguments: TkeyFuncOtherArguments,
+    initFuncOtherArguments: TinitFuncOtherArguments,
+    reduceFuncOtherArguments: TreduceFuncOtherArguments,
+    finalizeFuncOtherArguments: TfinalizeFuncOtherArguments,
+    keyFunc: (KeyfuncIn) -> KeyfuncOut,
+    initFunc: (InitfuncIn) -> InitfuncOut,
+    reduceFunc: (ReducefuncIn) -> ReducefuncOut,
+    finalizeFunc: (FinalizefuncIn) -> FinalizefuncOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalGroupByReducerDataset", nOutputs)
+    op.updateAttribute("key_func", keyFunc)
+    op.updateAttribute("init_func", initFunc)
+    op.updateAttribute("reduce_func", reduceFunc)
+    op.updateAttribute("finalize_func", finalizeFunc)
+    op.updateAttribute("Tkey_func_other_arguments", keyFuncOtherArguments._typeList)
+    op.updateAttribute("Tinit_func_other_arguments", initFuncOtherArguments._typeList)
+    op.updateAttribute("Treduce_func_other_arguments", reduceFuncOtherArguments._typeList)
+    op.updateAttribute("Tfinalize_func_other_arguments", finalizeFuncOtherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInputList(keyFuncOtherArguments)
+    op.addInputList(initFuncOtherArguments)
+    op.addInputList(reduceFuncOtherArguments)
+    op.addInputList(finalizeFuncOtherArguments)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that computes a windowed group-by on `input_dataset`.
+///
+/// // TODO(mrry): Support non-int64 keys.
+///
+/// - Attr key_func: A function mapping an element of `input_dataset`, concatenated
+///     with `key_func_other_arguments` to a scalar value of type DT_INT64.
+@inlinable @inline(__always)
+public static func experimentalGroupByWindowDataset<
+    KeyfuncIn: TensorGroup,
+    KeyfuncOut: TensorGroup,
+    ReducefuncIn: TensorGroup,
+    ReducefuncOut: TensorGroup,
+    WindowsizefuncIn: TensorGroup,
+    WindowsizefuncOut: TensorGroup,
+    TkeyFuncOtherArguments: TensorArrayProtocol,
+    TreduceFuncOtherArguments: TensorArrayProtocol,
+    TwindowSizeFuncOtherArguments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    keyFuncOtherArguments: TkeyFuncOtherArguments,
+    reduceFuncOtherArguments: TreduceFuncOtherArguments,
+    windowSizeFuncOtherArguments: TwindowSizeFuncOtherArguments,
+    keyFunc: (KeyfuncIn) -> KeyfuncOut,
+    reduceFunc: (ReducefuncIn) -> ReducefuncOut,
+    windowSizeFunc: (WindowsizefuncIn) -> WindowsizefuncOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalGroupByWindowDataset", nOutputs)
+    op.updateAttribute("key_func", keyFunc)
+    op.updateAttribute("reduce_func", reduceFunc)
+    op.updateAttribute("window_size_func", windowSizeFunc)
+    op.updateAttribute("Tkey_func_other_arguments", keyFuncOtherArguments._typeList)
+    op.updateAttribute("Treduce_func_other_arguments", reduceFuncOtherArguments._typeList)
+    op.updateAttribute("Twindow_size_func_other_arguments", windowSizeFuncOtherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInputList(keyFuncOtherArguments)
+    op.addInputList(reduceFuncOtherArguments)
+    op.addInputList(windowSizeFuncOtherArguments)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalIdentityIndexedDataset(
+    size: Tensor<UInt64>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalIdentityIndexedDataset", nOutputs)
+    op.addInput(size)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that contains the elements of `input_dataset` ignoring errors.
+@inlinable @inline(__always)
+public static func experimentalIgnoreErrorsDataset(
+    inputDataset: VariantHandle,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalIgnoreErrorsDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalIndexedDatasetGet<OutputTypes: TensorGroup>(
+    materialized: ResourceHandle,
+    index: Tensor<UInt64>,
+    outputShapes: [TensorShape?]
+) -> OutputTypes {
+  let nOutputs = Int(OutputTypes._typeList.count)
+    let op = makeOp("ExperimentalIndexedDatasetGet", nOutputs)
+    op.updateAttribute("output_types", OutputTypes._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(materialized)
+    op.addInput(index)
+    return op.execute(Int(OutputTypes._typeList.count))
+}
+
+@inlinable @inline(__always)
+public static func experimentalIndexedDatasetMaterialize(
+    dataset: VariantHandle,
+    materialized: ResourceHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("ExperimentalIndexedDatasetMaterialize", nOutputs)
+    op.addInput(dataset)
+    op.addInput(materialized)
+    op.execute()
+}
+
+/// Returns the name of the device on which `resource` has been placed.
+@inlinable @inline(__always)
+public static func experimentalIteratorGetDevice(
+    resource: ResourceHandle
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalIteratorGetDevice", nOutputs)
+    op.addInput(resource)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalLMDBDataset(
+    filenames: StringTensor,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalLMDBDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(filenames)
+    return op.execute(Int(1))
+}
+
+/// Records the latency of producing `input_dataset` elements in a StatsAggregator.
+@inlinable @inline(__always)
+public static func experimentalLatencyStatsDataset(
+    inputDataset: VariantHandle,
+    tag: StringTensor,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalLatencyStatsDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(tag)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that fuses mapping with batching.
+///
+/// Creates a dataset that applies `f` to the outputs of `input_dataset` and then
+/// batches `batch_size` of them.
+///
+/// Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
+/// to `batch_size * num_parallel_batches` copies of `f` in parallel.
+///
+/// - Parameters:
+///     - input_dataset: A variant tensor representing the input dataset.
+///     - other_arguments: A list of tensors, typically values that were captured when building a closure
+///         for `f`.
+///     - batch_size: A scalar representing the number of elements to accumulate in a
+///         batch. It determines the number of concurrent invocations of `f` that process
+///         elements from `input_dataset` in parallel.
+///     - num_parallel_calls: A scalar representing the maximum number of parallel invocations of the `map_fn`
+///         function. Applying the `map_fn` on consecutive input elements in parallel has
+///         the potential to improve input pipeline throughput.
+///     - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
+///         is smaller than desired.
+///
+/// - Attr f: A function to apply to the outputs of `input_dataset`.
+@inlinable @inline(__always)
+public static func experimentalMapAndBatchDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    otherArguments: Targuments,
+    batchSize: Tensor<Int64>,
+    numParallelCalls: Tensor<Int64>,
+    dropRemainder: Tensor<Bool>,
+    f: (FIn) -> FOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?],
+    preserveCardinality: Bool = false
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalMapAndBatchDataset", nOutputs)
+    op.updateAttribute("f", f)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("preserve_cardinality", preserveCardinality)
+    op.addInput(inputDataset)
+    op.addInputList(otherArguments)
+    op.addInput(batchSize)
+    op.addInput(numParallelCalls)
+    op.addInput(dropRemainder)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+@inlinable @inline(__always)
+public static func experimentalMapDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    otherArguments: Targuments,
+    f: (FIn) -> FOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?],
+    useInterOpParallelism: Bool = true,
+    preserveCardinality: Bool = false
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalMapDataset", nOutputs)
+    op.updateAttribute("f", f)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("use_inter_op_parallelism", useInterOpParallelism)
+    op.updateAttribute("preserve_cardinality", preserveCardinality)
+    op.addInput(inputDataset)
+    op.addInputList(otherArguments)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalMatchingFilesDataset(
+    patterns: StringTensor
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalMatchingFilesDataset", nOutputs)
+    op.addInput(patterns)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalMaterializedIndexDatasetHandle(
+    container: String,
+    sharedName: String,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalMaterializedIndexDatasetHandle", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that overrides the maximum intra-op parallelism.
+///
+/// - Parameter max_intra_op_parallelism: Identifies the maximum intra-op parallelism to use.
+@inlinable @inline(__always)
+public static func experimentalMaxIntraOpParallelismDataset(
+    inputDataset: VariantHandle,
+    maxIntraOpParallelism: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalMaxIntraOpParallelismDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(maxIntraOpParallelism)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalNonSerializableDataset(
+    inputDataset: VariantHandle,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalNonSerializableDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that fuses mapping with batching.
+///
+/// Creates a dataset that applies `f` to the outputs of `input_dataset` and then
+/// batches `batch_size` of them.
+///
+/// Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
+/// to `batch_size * num_parallel_batches` copies of `f` in parallel.
+///
+/// Unlike "MapAndBatchDatasetV2", this dataset uses a NUMA-aware thread scheduling
+/// policy. Because it uses the single-threaded executor, it only supports the
+/// function-based control flow ops.
+///
+/// - Parameters:
+///     - input_dataset: A variant tensor representing the input dataset.
+///     - other_arguments: A list of tensors, typically values that were captured when building a closure
+///         for `f`.
+///     - batch_size: A scalar representing the number of elements to accumulate in a
+///         batch. It determines the number of concurrent invocations of `f` that process
+///         elements from `input_dataset` in parallel.
+///     - num_parallel_calls: A scalar representing the maximum number of parallel invocations of the `map_fn`
+///         function. Applying the `map_fn` on consecutive input elements in parallel has
+///         the potential to improve input pipeline throughput.
+///     - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
+///         is smaller than desired.
+///
+/// - Attr f: A function to apply to the outputs of `input_dataset`.
+@inlinable @inline(__always)
+public static func experimentalNumaMapAndBatchDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    otherArguments: Targuments,
+    batchSize: Tensor<Int64>,
+    numParallelCalls: Tensor<Int64>,
+    dropRemainder: Tensor<Bool>,
+    f: (FIn) -> FOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?],
+    preserveCardinality: Bool = false
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalNumaMapAndBatchDataset", nOutputs)
+    op.updateAttribute("f", f)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("preserve_cardinality", preserveCardinality)
+    op.addInput(inputDataset)
+    op.addInputList(otherArguments)
+    op.addInput(batchSize)
+    op.addInput(numParallelCalls)
+    op.addInput(dropRemainder)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+///
+/// The resulting dataset is similar to the `InterleaveDataset`, with the exception
+/// that if retrieving the next value from a dataset would cause the requester to
+/// block, it will skip that input dataset. This dataset is especially useful
+/// when loading data from a variable-latency datastores (e.g. HDFS, GCS), as it
+/// allows the training step to proceed so long as some data is available.
+///
+/// !! WARNING !! This dataset is not deterministic!
+///
+/// - Attr f: A function mapping elements of `input_dataset`, concatenated with
+///     `other_arguments`, to a Dataset variant that contains elements matching
+///     `output_types` and `output_shapes`.
+@inlinable @inline(__always)
+public static func experimentalParallelInterleaveDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    otherArguments: Targuments,
+    cycleLength: Tensor<Int64>,
+    blockLength: Tensor<Int64>,
+    sloppy: Tensor<Bool>,
+    bufferOutputElements: Tensor<Int64>,
+    prefetchInputElements: Tensor<Int64>,
+    f: (FIn) -> FOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalParallelInterleaveDataset", nOutputs)
+    op.updateAttribute("f", f)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInputList(otherArguments)
+    op.addInput(cycleLength)
+    op.addInput(blockLength)
+    op.addInput(sloppy)
+    op.addInput(bufferOutputElements)
+    op.addInput(prefetchInputElements)
+    return op.execute(Int(1))
+}
+
+/// Transforms `input_dataset` containing `Example` protos as vectors of DT_STRING into a dataset of `Tensor` or `SparseTensor` objects representing the parsed features.
+///
+/// - Parameter dense_defaults: A dict mapping string keys to `Tensor`s.
+///     The keys of the dict must match the dense_keys of the feature.
+///
+/// - Attrs:
+///     - sparse_keys: A list of string keys in the examples features.
+///         The results for these keys will be returned as `SparseTensor` objects.
+///     - dense_keys: A list of Ndense string Tensors (scalars).
+///         The keys expected in the Examples features associated with dense values.
+///     - sparse_types: A list of `DTypes` of the same length as `sparse_keys`.
+///         Only `tf.float32` (`FloatList`), `tf.int64` (`Int64List`),
+///         and `tf.string` (`BytesList`) are supported.
+///     - Tdense: A list of DTypes of the same length as `dense_keys`.
+///         Only `tf.float32` (`FloatList`), `tf.int64` (`Int64List`),
+///         and `tf.string` (`BytesList`) are supported.
+///
+///     - dense_shapes: List of tuples with the same length as `dense_keys`.
+///         The shape of the data for each dense feature referenced by `dense_keys`.
+///         Required for any input tensors identified by `dense_keys`.  Must be
+///         either fully defined, or may contain an unknown first dimension.
+///         An unknown first dimension means the feature is treated as having
+///         a variable number of blocks, and the output shape along this dimension
+///         is considered unknown at graph build time.  Padding is applied for
+///         minibatch elements smaller than the maximum number of blocks for the
+///         given feature along this dimension.
+///     - output_types: The type list for the return values.
+///     - output_shapes: The list of shapes being produced.
+@inlinable @inline(__always)
+public static func experimentalParseExampleDataset<Tdense: TensorArrayProtocol>(
+    inputDataset: VariantHandle,
+    numParallelCalls: Tensor<Int64>,
+    denseDefaults: Tdense,
+    sparseKeys: [String],
+    denseKeys: [String],
+    sparseTypes: [TensorDataType],
+    denseShapes: [TensorShape?],
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?],
+    sloppy: Bool = false
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalParseExampleDataset", nOutputs)
+    op.updateAttribute("sparse_keys", sparseKeys)
+    op.updateAttribute("dense_keys", denseKeys)
+    op.updateAttribute("sparse_types", sparseTypes)
+    op.updateAttribute("Tdense", denseDefaults._typeList)
+    op.updateAttribute("dense_shapes", denseShapes)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("sloppy", sloppy)
+    op.addInput(inputDataset)
+    op.addInput(numParallelCalls)
+    op.addInputList(denseDefaults)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that uses a custom thread pool to compute `input_dataset`.
+///
+/// - Parameter num_threads: Identifies the number of threads to use for the private threadpool.
+@inlinable @inline(__always)
+public static func experimentalPrivateThreadPoolDataset(
+    inputDataset: VariantHandle,
+    numThreads: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalPrivateThreadPoolDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(numThreads)
+    return op.execute(Int(1))
+}
+
+/// Creates a Dataset that returns pseudorandom numbers.
+///
+/// - Parameters:
+///     - seed: A scalar seed for the random number generator. If either seed or
+///         seed2 is set to be non-zero, the random number generator is seeded
+///         by the given seed.  Otherwise, a random seed is used.
+///     - seed2: A second scalar seed to avoid seed collision.
+@inlinable @inline(__always)
+public static func experimentalRandomDataset(
+    seed: Tensor<Int64>,
+    seed2: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalRandomDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(seed)
+    op.addInput(seed2)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that changes the batch size.
+///
+/// Creates a dataset that changes the batch size of the dataset to current batch
+/// size // num_workers.
+///
+/// - Parameters:
+///     - input_dataset: A variant tensor representing the input dataset.
+///     - num_workers: A scalar representing the number of workers to distribute this batch across. As
+///         a result of this transformation the current batch size would end up being
+///         divided  by this parameter.
+@inlinable @inline(__always)
+public static func experimentalRebatchDataset(
+    inputDataset: VariantHandle,
+    numWorkers: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalRebatchDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(numWorkers)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset successively reduces `f` over the elements of `input_dataset`.
+@inlinable @inline(__always)
+public static func experimentalScanDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Tstate: TensorArrayProtocol,
+    Targuments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    initialState: Tstate,
+    otherArguments: Targuments,
+    f: (FIn) -> FOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?],
+    preserveCardinality: Bool = false
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalScanDataset", nOutputs)
+    op.updateAttribute("f", f)
+    op.updateAttribute("Tstate", initialState._typeList)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("preserve_cardinality", preserveCardinality)
+    op.addInput(inputDataset)
+    op.addInputList(initialState)
+    op.addInputList(otherArguments)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalSetStatsAggregatorDataset(
+    inputDataset: VariantHandle,
+    statsAggregator: ResourceHandle,
+    tag: StringTensor,
+    counterPrefix: StringTensor,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalSetStatsAggregatorDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(statsAggregator)
+    op.addInput(tag)
+    op.addInput(counterPrefix)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func experimentalSleepDataset(
+    inputDataset: VariantHandle,
+    sleepMicroseconds: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalSleepDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(sleepMicroseconds)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that passes a sliding window over `input_dataset`.
+///
+/// - Parameters:
+///     - window_size: A scalar representing the number of elements in the
+///         sliding window.
+///     - window_shift: A scalar representing the steps moving the sliding window
+///         forward in one iteration. It must be positive.
+///     - window_stride: A scalar representing the stride of the input elements of the sliding window.
+///         It must be positive.
+@inlinable @inline(__always)
+public static func experimentalSlidingWindowDataset(
+    inputDataset: VariantHandle,
+    windowSize: Tensor<Int64>,
+    windowShift: Tensor<Int64>,
+    windowStride: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalSlidingWindowDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(windowSize)
+    op.addInput(windowShift)
+    op.addInput(windowStride)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that executes a SQL query and emits rows of the result set.
+///
+/// - Parameters:
+///     - driver_name: The database type. Currently, the only supported type is 'sqlite'.
+///     - data_source_name: A connection string to connect to the database.
+///     - query: A SQL query to execute.
+@inlinable @inline(__always)
+public static func experimentalSqlDataset(
+    driverName: StringTensor,
+    dataSourceName: StringTensor,
+    query: StringTensor,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalSqlDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(driverName)
+    op.addInput(dataSourceName)
+    op.addInput(query)
+    return op.execute(Int(1))
+}
+
+/// Creates a statistics manager resource.
+@inlinable @inline(__always)
+public static func experimentalStatsAggregatorHandle(
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalStatsAggregatorHandle", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Produces a summary of any statistics recorded by the given statistics manager.
+@inlinable @inline(__always)
+public static func experimentalStatsAggregatorSummary(
+    iterator: ResourceHandle
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalStatsAggregatorSummary", nOutputs)
+    op.addInput(iterator)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that stops iteration when predicate` is false.
+///
+/// The `predicate` function must return a scalar boolean and accept the
+/// following arguments:
+///
+/// * One tensor for each component of an element of `input_dataset`.
+/// * One tensor for each value in `other_arguments`.
+///
+/// - Parameter other_arguments: A list of tensors, typically values that were captured when
+///     building a closure for `predicate`.
+///
+/// - Attr predicate: A function returning a scalar boolean.
+@inlinable @inline(__always)
+public static func experimentalTakeWhileDataset<
+    PredicateIn: TensorGroup,
+    PredicateOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    otherArguments: Targuments,
+    predicate: (PredicateIn) -> PredicateOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalTakeWhileDataset", nOutputs)
+    op.updateAttribute("predicate", predicate)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInputList(otherArguments)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that uses a custom thread pool to compute `input_dataset`.
+///
+/// - Parameter thread_pool: A resource produced by the ThreadPoolHandle op.
+@inlinable @inline(__always)
+public static func experimentalThreadPoolDataset(
+    inputDataset: VariantHandle,
+    threadPool: ResourceHandle,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalThreadPoolDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(threadPool)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that uses a custom thread pool to compute `input_dataset`.
+///
+/// - Attrs:
+///     - num_threads: The number of threads in the thread pool.
+///     - max_intra_op_parallelism: The maximum degree of parallelism to use within operations that execute on this
+///         threadpool.
+///     - display_name: A human-readable name for the threads that may be visible in some
+///         visualizations.
+///         threadpool.
+///
+/// - Output handle: A resource that can be consumed by one or more ExperimentalThreadPoolDataset
+///     ops.
+@inlinable @inline(__always)
+public static func experimentalThreadPoolHandle(
+    numThreads: Int64,
+    maxIntraOpParallelism: Int64 = 1,
+    displayName: String,
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalThreadPoolHandle", nOutputs)
+    op.updateAttribute("num_threads", numThreads)
+    op.updateAttribute("max_intra_op_parallelism", maxIntraOpParallelism)
+    op.updateAttribute("display_name", displayName)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// A dataset that splits the elements of its input into multiple elements.
+@inlinable @inline(__always)
+public static func experimentalUnbatchDataset(
+    inputDataset: VariantHandle,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalUnbatchDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that contains the unique elements of `input_dataset`.
+@inlinable @inline(__always)
+public static func experimentalUniqueDataset(
+    inputDataset: VariantHandle,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ExperimentalUniqueDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    return op.execute(Int(1))
+}
+
+/// Computes exponential of x - 1 element-wise.
+///
+/// I.e., \\(y = (\exp x) - 1\\).
+@inlinable @inline(__always)
+public static func expm1<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Expm1", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Extracts a glimpse from the input tensor.
+///
+/// Returns a set of windows called glimpses extracted at location
+/// `offsets` from the input tensor. If the windows only partially
+/// overlaps the inputs, the non overlapping areas will be filled with
+/// random noise.
+///
+/// The result is a 4-D tensor of shape `[batch_size, glimpse_height,
+/// glimpse_width, channels]`. The channels and batch dimensions are the
+/// same as that of the input tensor. The height and width of the output
+/// windows are specified in the `size` parameter.
+///
+/// The argument `normalized` and `centered` controls how the windows are built:
+///
+/// * If the coordinates are normalized but not centered, 0.0 and 1.0
+///   correspond to the minimum and maximum of each height and width
+///   dimension.
+/// * If the coordinates are both normalized and centered, they range from
+///   -1.0 to 1.0. The coordinates (-1.0, -1.0) correspond to the upper
+///   left corner, the lower right corner is located at (1.0, 1.0) and the
+///   center is at (0, 0).
+/// * If the coordinates are not normalized they are interpreted as
+///   numbers of pixels.
+///
+/// - Parameters:
+///     - input: A 4-D float tensor of shape `[batch_size, height, width, channels]`.
+///     - size: A 1-D tensor of 2 elements containing the size of the glimpses
+///         to extract.  The glimpse height must be specified first, following
+///         by the glimpse width.
+///     - offsets: A 2-D integer tensor of shape `[batch_size, 2]` containing
+///         the y, x locations of the center of each window.
+///
+/// - Attrs:
+///     - centered: indicates if the offset coordinates are centered relative to
+///         the image, in which case the (0, 0) offset is relative to the center
+///         of the input images. If false, the (0,0) offset corresponds to the
+///         upper left corner of the input images.
+///     - normalized: indicates if the offset coordinates are normalized.
+///     - uniform_noise: indicates if the noise should be generated using a
+///         uniform distribution or a Gaussian distribution.
+///     - noise: indicates if the noise should `uniform`, `gaussian`, or
+///         `zero`. The default is `uniform` which means the the noise type
+///         will be decided by `uniform_noise`.
+///
+/// - Output glimpse: A tensor representing the glimpses `[batch_size,
+///     glimpse_height, glimpse_width, channels]`.
+@inlinable @inline(__always)
+public static func extractGlimpse(
+    _ input: Tensor<Float>,
+    size: Tensor<Int32>,
+    offsets: Tensor<Float>,
+    centered: Bool = true,
+    normalized: Bool = true,
+    uniformNoise: Bool = true,
+    noise: String = "uniform"
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("ExtractGlimpse", nOutputs)
+    op.updateAttribute("centered", centered)
+    op.updateAttribute("normalized", normalized)
+    op.updateAttribute("uniform_noise", uniformNoise)
+    op.updateAttribute("noise", noise)
+    op.addInput(input)
+    op.addInput(size)
+    op.addInput(offsets)
+    return op.execute(Int(1))
+}
+
+/// Extract `patches` from `images` and put them in the "depth" output dimension.
+///
+/// - Parameter images: 4-D Tensor with shape `[batch, in_rows, in_cols, depth]`.
+///
+/// - Attrs:
+///     - ksizes: The size of the sliding window for each dimension of `images`.
+///     - strides: 1-D of length 4. How far the centers of two consecutive patches are in
+///         the images. Must be: `[1, stride_rows, stride_cols, 1]`.
+///     - rates: 1-D of length 4. Must be: `[1, rate_rows, rate_cols, 1]`. This is the
+///         input stride, specifying how far two consecutive patch samples are in the
+///         input. Equivalent to extracting patches with
+///         `patch_sizes_eff = patch_sizes + (patch_sizes - 1) * (rates - 1)`, followed by
+///         subsampling them spatially by a factor of `rates`. This is equivalent to
+///         `rate` in dilated (a.k.a. Atrous) convolutions.
+///     - padding: The type of padding algorithm to use.
+///
+///         We specify the size-related attributes as:
+///
+///         ```python
+///               ksizes = [1, ksize_rows, ksize_cols, 1]
+///               strides = [1, strides_rows, strides_cols, 1]
+///               rates = [1, rates_rows, rates_cols, 1]
+///         ```
+///
+/// - Output patches: 4-D Tensor with shape `[batch, out_rows, out_cols, ksize_rows *
+///     ksize_cols * depth]` containing image patches with size
+///     `ksize_rows x ksize_cols x depth` vectorized in the "depth" dimension. Note
+///     `out_rows` and `out_cols` are the dimensions of the output patches.
+@inlinable @inline(__always)
+public static func extractImagePatches<T: Numeric & TensorFlowScalar>(
+    images: Tensor<T>,
+    ksizes: [Int32],
+    strides: [Int32],
+    rates: [Int32],
+    padding: Padding
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ExtractImagePatches", nOutputs)
+    op.updateAttribute("ksizes", ksizes)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("rates", rates)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("padding", padding.cName)
+    op.addInput(images)
+    return op.execute(Int(1))
+}
+
+/// Extract the shape information of a JPEG-encoded image.
+///
+/// This op only parses the image header, so it is much faster than DecodeJpeg.
+///
+/// - Parameter contents: 0-D. The JPEG-encoded image.
+///
+/// - Attr output_type: (Optional) The output type of the operation (int32 or int64).
+///     Defaults to int32.
+///
+/// - Output image_shape: 1-D. The image shape with format [height, width, channels].
+@inlinable @inline(__always)
+public static func extractJpegShape<OutputType: BinaryInteger & TensorFlowScalar>(
+    contents: StringTensor
+) -> Tensor<OutputType> {
+  let nOutputs = Int(1)
+    let op = makeOp("ExtractJpegShape", nOutputs)
+    op.updateAttribute("output_type", OutputType.tensorFlowDataType)
+    op.addInput(contents)
+    return op.execute(Int(1))
+}
+
+/// Extract `patches` from `input` and put them in the "depth" output dimension. 3D extension of `extract_image_patches`.
+///
+/// - Parameter input: 5-D Tensor with shape `[batch, in_planes, in_rows, in_cols, depth]`.
+///
+/// - Attrs:
+///     - ksizes: The size of the sliding window for each dimension of `input`.
+///     - strides: 1-D of length 5. How far the centers of two consecutive patches are in
+///         `input`. Must be: `[1, stride_planes, stride_rows, stride_cols, 1]`.
+///     - padding: The type of padding algorithm to use.
+///
+///         We specify the size-related attributes as:
+///
+///         ```python
+///               ksizes = [1, ksize_planes, ksize_rows, ksize_cols, 1]
+///               strides = [1, stride_planes, strides_rows, strides_cols, 1]
+///         ```
+///
+/// - Output patches: 5-D Tensor with shape `[batch, out_planes, out_rows, out_cols,
+///     ksize_planes * ksize_rows * ksize_cols * depth]` containing patches
+///     with size `ksize_planes x ksize_rows x ksize_cols x depth` vectorized
+///     in the "depth" dimension. Note `out_planes`, `out_rows` and `out_cols`
+///     are the dimensions of the output patches.
+@inlinable @inline(__always)
+public static func extractVolumePatches<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    ksizes: [Int32],
+    strides: [Int32],
+    padding: Padding
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ExtractVolumePatches", nOutputs)
+    op.updateAttribute("ksizes", ksizes)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("padding", padding.cName)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Fast Fourier transform.
+///
+/// Computes the 1-dimensional discrete Fourier transform over the inner-most
+/// dimension of `input`.
+///
+/// - Parameter input: A complex tensor.
+///
+/// - Output output: A complex tensor of the same shape as `input`. The inner-most
+///       dimension of `input` is replaced with its 1D Fourier transform.
+///
+///     @compatibility(numpy)
+///     Equivalent to np.fft.fft
+///     @end_compatibility
+@inlinable @inline(__always)
+public static func fFT<Tcomplex: TensorFlowScalar>(
+    _ input: Tensor<Tcomplex>
+) -> Tensor<Tcomplex> {
+  let nOutputs = Int(1)
+    let op = makeOp("FFT", nOutputs)
+    op.updateAttribute("Tcomplex", Tcomplex.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// 2D fast Fourier transform.
+///
+/// Computes the 2-dimensional discrete Fourier transform over the inner-most
+/// 2 dimensions of `input`.
+///
+/// - Parameter input: A complex tensor.
+///
+/// - Output output: A complex tensor of the same shape as `input`. The inner-most 2
+///       dimensions of `input` are replaced with their 2D Fourier transform.
+///
+///     @compatibility(numpy)
+///     Equivalent to np.fft.fft2
+///     @end_compatibility
+@inlinable @inline(__always)
+public static func fFT2D<Tcomplex: TensorFlowScalar>(
+    _ input: Tensor<Tcomplex>
+) -> Tensor<Tcomplex> {
+  let nOutputs = Int(1)
+    let op = makeOp("FFT2D", nOutputs)
+    op.updateAttribute("Tcomplex", Tcomplex.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// 3D fast Fourier transform.
+///
+/// Computes the 3-dimensional discrete Fourier transform over the inner-most 3
+/// dimensions of `input`.
+///
+/// - Parameter input: A complex64 tensor.
+///
+/// - Output output: A complex64 tensor of the same shape as `input`. The inner-most 3
+///       dimensions of `input` are replaced with their 3D Fourier transform.
+///
+///     @compatibility(numpy)
+///     Equivalent to np.fft.fftn with 3 dimensions.
+///     @end_compatibility
+@inlinable @inline(__always)
+public static func fFT3D<Tcomplex: TensorFlowScalar>(
+    _ input: Tensor<Tcomplex>
+) -> Tensor<Tcomplex> {
+  let nOutputs = Int(1)
+    let op = makeOp("FFT3D", nOutputs)
+    op.updateAttribute("Tcomplex", Tcomplex.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// A queue that produces elements in first-in first-out order.
+///
+/// - Attrs:
+///     - component_types: The type of each component in a value.
+///     - shapes: The shape of each component in a value. The length of this attr must
+///         be either 0 or the same as the length of component_types. If the length of
+///         this attr is 0, the shapes of queue elements are not constrained, and
+///         only one element may be dequeued at a time.
+///     - capacity: The upper bound on the number of elements in this queue.
+///         Negative numbers mean no limit.
+///     - container: If non-empty, this queue is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this queue will be shared under the given name
+///         across multiple sessions.
+///
+/// - Output handle: The handle to the queue.
+@inlinable @inline(__always)
+public static func fIFOQueueV2(
+    componentTypes: [TensorDataType],
+    shapes: [TensorShape?],
+    capacity: Int64 = -1,
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("FIFOQueueV2", nOutputs)
+    op.updateAttribute("component_types", componentTypes)
+    op.updateAttribute("shapes", shapes)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Output a fact about factorials.
+@inlinable @inline(__always)
+public static func fact(
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("Fact", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+///   This op is used as a placeholder in If branch functions. It doesn't provide a
+///   valid output when run, so must either be removed (e.g. replaced with a
+///   function input) or guaranteed not to be used (e.g. if mirroring an
+///   intermediate output needed for the gradient computation of the other branch).
+///
+/// - Attrs:
+///     - dtype: The type of the output.
+///     - shape:     The purported shape of the output. This is only used for shape inference;
+///             the output will not necessarily have this shape. Can be a partial shape.
+///
+/// - Output output:     \"Fake\" output value. This should not be consumed by another op.
+@inlinable @inline(__always)
+public static func fakeParam<Dtype: TensorFlowScalar>(
+    shape: TensorShape?
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("FakeParam", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape", shape)
+    return op.execute(Int(1))
+}
+
+/// Fake-quantize the 'inputs' tensor, type float to 'outputs' tensor of same type.
+///
+/// Attributes `[min; max]` define the clamping range for the `inputs` data.
+/// `inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
+/// when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
+/// then de-quantized and output as floats in `[min; max]` interval.
+/// `num_bits` is the bitwidth of the quantization; between 2 and 16, inclusive.
+///
+/// Before quantization, `min` and `max` values are adjusted with the following
+/// logic.
+/// It is suggested to have `min <= 0 <= max`. If `0` is not in the range of values,
+/// the behavior can be unexpected:
+/// If `0 < min < max`: `min_adj = 0` and `max_adj = max - min`.
+/// If `min < max < 0`: `min_adj = min - max` and `max_adj = 0`.
+/// If `min <= 0 <= max`: `scale = (max - min) / (2^num_bits - 1) `,
+/// `min_adj = scale * round(min / scale)` and `max_adj = max + min_adj - min`.
+///
+/// Quantization is called fake since the output is still in floating point.
+@inlinable @inline(__always)
+public static func fakeQuantWithMinMaxArgs(
+    inputs: Tensor<Float>,
+    min: Double = -6,
+    max: Double = 6,
+    numBits: Int64 = 8,
+    narrowRange: Bool = false
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("FakeQuantWithMinMaxArgs", nOutputs)
+    op.updateAttribute("min", min)
+    op.updateAttribute("max", max)
+    op.updateAttribute("num_bits", numBits)
+    op.updateAttribute("narrow_range", narrowRange)
+    op.addInput(inputs)
+    return op.execute(Int(1))
+}
+
+/// Compute gradients for a FakeQuantWithMinMaxArgs operation.
+///
+/// - Parameters:
+///     - gradients: Backpropagated gradients above the FakeQuantWithMinMaxArgs operation.
+///     - inputs: Values passed as inputs to the FakeQuantWithMinMaxArgs operation.
+///
+/// - Output backprops: Backpropagated gradients below the FakeQuantWithMinMaxArgs operation:
+///     `gradients * (inputs >= min && inputs <= max)`.
+@inlinable @inline(__always)
+public static func fakeQuantWithMinMaxArgsGradient(
+    gradients: Tensor<Float>,
+    inputs: Tensor<Float>,
+    min: Double = -6,
+    max: Double = 6,
+    numBits: Int64 = 8,
+    narrowRange: Bool = false
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("FakeQuantWithMinMaxArgsGradient", nOutputs)
+    op.updateAttribute("min", min)
+    op.updateAttribute("max", max)
+    op.updateAttribute("num_bits", numBits)
+    op.updateAttribute("narrow_range", narrowRange)
+    op.addInput(gradients)
+    op.addInput(inputs)
+    return op.execute(Int(1))
+}
+
+/// Fake-quantize the 'inputs' tensor of type float via global float scalars `min`
+///
+/// and `max` to 'outputs' tensor of same shape as `inputs`.
+///
+/// `[min; max]` define the clamping range for the `inputs` data.
+/// `inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
+/// when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
+/// then de-quantized and output as floats in `[min; max]` interval.
+/// `num_bits` is the bitwidth of the quantization; between 2 and 16, inclusive.
+///
+/// Before quantization, `min` and `max` values are adjusted with the following
+/// logic.
+/// It is suggested to have `min <= 0 <= max`. If `0` is not in the range of values,
+/// the behavior can be unexpected:
+/// If `0 < min < max`: `min_adj = 0` and `max_adj = max - min`.
+/// If `min < max < 0`: `min_adj = min - max` and `max_adj = 0`.
+/// If `min <= 0 <= max`: `scale = (max - min) / (2^num_bits - 1) `,
+/// `min_adj = scale * round(min / scale)` and `max_adj = max + min_adj - min`.
+///
+/// This operation has a gradient and thus allows for training `min` and `max`
+/// values.
+@inlinable @inline(__always)
+public static func fakeQuantWithMinMaxVars(
+    inputs: Tensor<Float>,
+    min: Tensor<Float>,
+    max: Tensor<Float>,
+    numBits: Int64 = 8,
+    narrowRange: Bool = false
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("FakeQuantWithMinMaxVars", nOutputs)
+    op.updateAttribute("num_bits", numBits)
+    op.updateAttribute("narrow_range", narrowRange)
+    op.addInput(inputs)
+    op.addInput(min)
+    op.addInput(max)
+    return op.execute(Int(1))
+}
+
+/// Compute gradients for a FakeQuantWithMinMaxVars operation.
+///
+/// - Parameters:
+///     - gradients: Backpropagated gradients above the FakeQuantWithMinMaxVars operation.
+///     - inputs: Values passed as inputs to the FakeQuantWithMinMaxVars operation.
+///         min, max: Quantization interval, scalar floats.
+///
+/// - Attrs:
+///     - num_bits: The bitwidth of the quantization; between 2 and 8, inclusive.
+///     - narrow_range: Whether to quantize into 2^num_bits - 1 distinct values.
+///
+/// - Outputs:
+///     - backprops_wrt_input: Backpropagated gradients w.r.t. inputs:
+///         `gradients * (inputs >= min && inputs <= max)`.
+///     - backprop_wrt_min: Backpropagated gradients w.r.t. min parameter:
+///         `sum(gradients * (inputs < min))`.
+///     - backprop_wrt_max: Backpropagated gradients w.r.t. max parameter:
+///         `sum(gradients * (inputs > max))`.
+@inlinable @inline(__always)
+public static func fakeQuantWithMinMaxVarsGradient(
+    gradients: Tensor<Float>,
+    inputs: Tensor<Float>,
+    min: Tensor<Float>,
+    max: Tensor<Float>,
+    numBits: Int64 = 8,
+    narrowRange: Bool = false
+) -> (backpropsWrtInput: Tensor<Float>, backpropWrtMin: Tensor<Float>, backpropWrtMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("FakeQuantWithMinMaxVarsGradient", nOutputs)
+    op.updateAttribute("num_bits", numBits)
+    op.updateAttribute("narrow_range", narrowRange)
+    op.addInput(gradients)
+    op.addInput(inputs)
+    op.addInput(min)
+    op.addInput(max)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Fake-quantize the 'inputs' tensor of type float and one of the shapes: `[d]`,
+///
+/// `[b, d]` `[b, h, w, d]` via per-channel floats `min` and `max` of shape `[d]`
+/// to 'outputs' tensor of same shape as `inputs`.
+///
+/// `[min; max]` define the clamping range for the `inputs` data.
+/// `inputs` values are quantized into the quantization range (`[0; 2^num_bits - 1]`
+/// when `narrow_range` is false and `[1; 2^num_bits - 1]` when it is true) and
+/// then de-quantized and output as floats in `[min; max]` interval.
+/// `num_bits` is the bitwidth of the quantization; between 2 and 16, inclusive.
+///
+/// Before quantization, `min` and `max` values are adjusted with the following
+/// logic.
+/// It is suggested to have `min <= 0 <= max`. If `0` is not in the range of values,
+/// the behavior can be unexpected:
+/// If `0 < min < max`: `min_adj = 0` and `max_adj = max - min`.
+/// If `min < max < 0`: `min_adj = min - max` and `max_adj = 0`.
+/// If `min <= 0 <= max`: `scale = (max - min) / (2^num_bits - 1) `,
+/// `min_adj = scale * round(min / scale)` and `max_adj = max + min_adj - min`.
+///
+/// This operation has a gradient and thus allows for training `min` and `max`
+/// values.
+@inlinable @inline(__always)
+public static func fakeQuantWithMinMaxVarsPerChannel(
+    inputs: Tensor<Float>,
+    min: Tensor<Float>,
+    max: Tensor<Float>,
+    numBits: Int64 = 8,
+    narrowRange: Bool = false
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("FakeQuantWithMinMaxVarsPerChannel", nOutputs)
+    op.updateAttribute("num_bits", numBits)
+    op.updateAttribute("narrow_range", narrowRange)
+    op.addInput(inputs)
+    op.addInput(min)
+    op.addInput(max)
+    return op.execute(Int(1))
+}
+
+/// Compute gradients for a FakeQuantWithMinMaxVarsPerChannel operation.
+///
+/// - Parameters:
+///     - gradients: Backpropagated gradients above the FakeQuantWithMinMaxVars operation,
+///         shape one of: `[d]`, `[b, d]`,  `[b, h, w, d]`.
+///     - inputs: Values passed as inputs to the FakeQuantWithMinMaxVars operation, shape
+///           same as `gradients`.
+///         min, max: Quantization interval, floats of shape `[d]`.
+///
+/// - Attrs:
+///     - num_bits: The bitwidth of the quantization; between 2 and 16, inclusive.
+///     - narrow_range: Whether to quantize into 2^num_bits - 1 distinct values.
+///
+/// - Outputs:
+///     - backprops_wrt_input: Backpropagated gradients w.r.t. inputs, shape same as
+///         `inputs`:
+///           `gradients * (inputs >= min && inputs <= max)`.
+///     - backprop_wrt_min: Backpropagated gradients w.r.t. min parameter, shape `[d]`:
+///         `sum_per_d(gradients * (inputs < min))`.
+///     - backprop_wrt_max: Backpropagated gradients w.r.t. max parameter, shape `[d]`:
+///         `sum_per_d(gradients * (inputs > max))`.
+@inlinable @inline(__always)
+public static func fakeQuantWithMinMaxVarsPerChannelGradient(
+    gradients: Tensor<Float>,
+    inputs: Tensor<Float>,
+    min: Tensor<Float>,
+    max: Tensor<Float>,
+    numBits: Int64 = 8,
+    narrowRange: Bool = false
+) -> (backpropsWrtInput: Tensor<Float>, backpropWrtMin: Tensor<Float>, backpropWrtMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("FakeQuantWithMinMaxVarsPerChannelGradient", nOutputs)
+    op.updateAttribute("num_bits", numBits)
+    op.updateAttribute("narrow_range", narrowRange)
+    op.addInput(gradients)
+    op.addInput(inputs)
+    op.addInput(min)
+    op.addInput(max)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Creates a tensor filled with a scalar value.
+///
+/// This operation creates a tensor of shape `dims` and fills it with `value`.
+///
+/// For example:
+///
+/// ```
+/// # Output tensor has shape [2, 3].
+/// fill([2, 3], 9) ==> [[9, 9, 9]
+///                      [9, 9, 9]]
+/// ```
+///
+/// `tf.fill` differs from `tf.constant` in a few ways:
+///
+/// *   `tf.fill` only supports scalar contents, whereas `tf.constant` supports
+///     Tensor values.
+/// *   `tf.fill` creates an Op in the computation graph that constructs the actual
+///     Tensor value at runtime. This is in contrast to `tf.constant` which embeds
+///     the entire Tensor into the graph with a `Const` node.
+/// *   Because `tf.fill` evaluates at graph runtime, it supports dynamic shapes
+///     based on other runtime Tensors, unlike `tf.constant`.
+///
+/// - Parameters:
+///     - dims: 1-D. Represents the shape of the output tensor.
+///     - value: 0-D (scalar). Value to fill the returned tensor.
+///
+///         @compatibility(numpy)
+///         Equivalent to np.full
+///         @end_compatibility
+@inlinable @inline(__always)
+public static func fill<
+    T: TensorFlowScalar,
+    IndexType: BinaryInteger & TensorFlowScalar
+>(
+    dims: Tensor<IndexType>,
+    value: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Fill", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("index_type", IndexType.tensorFlowDataType)
+    op.addInput(dims)
+    op.addInput(value)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset containing elements of first component of `input_dataset` having true in the last component.
+@inlinable @inline(__always)
+public static func filterByLastComponentDataset(
+    inputDataset: VariantHandle,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("FilterByLastComponentDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset containing elements of `input_dataset` matching `predicate`.
+///
+/// The `predicate` function must return a scalar boolean and accept the
+/// following arguments:
+///
+/// * One tensor for each component of an element of `input_dataset`.
+/// * One tensor for each value in `other_arguments`.
+///
+/// - Parameter other_arguments: A list of tensors, typically values that were captured when
+///     building a closure for `predicate`.
+///
+/// - Attr predicate: A function returning a scalar boolean.
+@inlinable @inline(__always)
+public static func filterDataset<
+    PredicateIn: TensorGroup,
+    PredicateOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    otherArguments: Targuments,
+    predicate: (PredicateIn) -> PredicateOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("FilterDataset", nOutputs)
+    op.updateAttribute("predicate", predicate)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInputList(otherArguments)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func fiveFloatOutputs(
+) -> (a: Tensor<Float>, b: Tensor<Float>, c: Tensor<Float>, d: Tensor<Float>, e: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("FiveFloatOutputs", nOutputs)
+    
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Creates a dataset that emits the records from one or more binary files.
+///
+/// - Parameters:
+///     - filenames: A scalar or a vector containing the name(s) of the file(s) to be
+///         read.
+///     - header_bytes: A scalar representing the number of bytes to skip at the
+///         beginning of a file.
+///     - record_bytes: A scalar representing the number of bytes in each record.
+///     - footer_bytes: A scalar representing the number of bytes to skip at the end
+///         of a file.
+///     - buffer_size: A scalar representing the number of bytes to buffer. Must be > 0.
+@inlinable @inline(__always)
+public static func fixedLengthRecordDataset(
+    filenames: StringTensor,
+    headerBytes: Tensor<Int64>,
+    recordBytes: Tensor<Int64>,
+    footerBytes: Tensor<Int64>,
+    bufferSize: Tensor<Int64>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("FixedLengthRecordDataset", nOutputs)
+    op.addInput(filenames)
+    op.addInput(headerBytes)
+    op.addInput(recordBytes)
+    op.addInput(footerBytes)
+    op.addInput(bufferSize)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func fixedLengthRecordDatasetV2(
+    filenames: StringTensor,
+    headerBytes: Tensor<Int64>,
+    recordBytes: Tensor<Int64>,
+    footerBytes: Tensor<Int64>,
+    bufferSize: Tensor<Int64>,
+    compressionType: StringTensor
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("FixedLengthRecordDatasetV2", nOutputs)
+    op.addInput(filenames)
+    op.addInput(headerBytes)
+    op.addInput(recordBytes)
+    op.addInput(footerBytes)
+    op.addInput(bufferSize)
+    op.addInput(compressionType)
+    return op.execute(Int(1))
+}
+
+/// A Reader that outputs fixed-length records from a file.
+///
+/// - Attrs:
+///     - header_bytes: Number of bytes in the header, defaults to 0.
+///     - record_bytes: Number of bytes in the record.
+///     - footer_bytes: Number of bytes in the footer, defaults to 0.
+///     - hop_bytes: Number of bytes to hop before each read. Default of 0 means using
+///         record_bytes.
+///     - container: If non-empty, this reader is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this reader is named in the given bucket
+///         with this shared_name. Otherwise, the node name is used instead.
+///     - encoding: The type of encoding for the file. Currently ZLIB and GZIP
+///         are supported. Defaults to none.
+///
+/// - Output reader_handle: The handle to reference the Reader.
+@inlinable @inline(__always)
+public static func fixedLengthRecordReaderV2(
+    headerBytes: Int64 = 0,
+    recordBytes: Int64,
+    footerBytes: Int64 = 0,
+    hopBytes: Int64 = 0,
+    container: String,
+    sharedName: String,
+    encoding: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("FixedLengthRecordReaderV2", nOutputs)
+    op.updateAttribute("header_bytes", headerBytes)
+    op.updateAttribute("record_bytes", recordBytes)
+    op.updateAttribute("footer_bytes", footerBytes)
+    op.updateAttribute("hop_bytes", hopBytes)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("encoding", encoding)
+    return op.execute(Int(1))
+}
+
+/// Generates labels for candidate sampling with a learned unigram distribution.
+///
+/// A unigram sampler could use a fixed unigram distribution read from a
+/// file or passed in as an in-memory array instead of building up the distribution
+/// from data on the fly. There is also an option to skew the distribution by
+/// applying a distortion power to the weights.
+///
+/// The vocabulary file should be in CSV-like format, with the last field
+/// being the weight associated with the word.
+///
+/// For each batch, this op picks a single set of sampled candidate labels.
+///
+/// The advantages of sampling candidates per-batch are simplicity and the
+/// possibility of efficient dense matrix multiplication. The disadvantage is that
+/// the sampled candidates must be chosen independently of the context and of the
+/// true labels.
+///
+/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
+///     IDs of the num_true target_classes in the corresponding original label.
+///
+/// - Attrs:
+///     - num_true: Number of true labels per context.
+///     - num_sampled: Number of candidates to randomly sample.
+///     - unique: If unique is true, we sample with rejection, so that all sampled
+///         candidates in a batch are unique. This requires some approximation to
+///         estimate the post-rejection sampling probabilities.
+///     - range_max: The sampler will sample integers from the interval [0, range_max).
+///     - vocab_file: Each valid line in this file (which should have a CSV-like format)
+///         corresponds to a valid word ID. IDs are in sequential order, starting from
+///         num_reserved_ids. The last entry in each line is expected to be a value
+///         corresponding to the count or relative probability. Exactly one of vocab_file
+///         and unigrams needs to be passed to this op.
+///     - distortion: The distortion is used to skew the unigram probability distribution.
+///         Each weight is first raised to the distortion's power before adding to the
+///         internal unigram distribution. As a result, distortion = 1.0 gives regular
+///         unigram sampling (as defined by the vocab file), and distortion = 0.0 gives
+///         a uniform distribution.
+///     - num_reserved_ids: Optionally some reserved IDs can be added in the range [0,
+///         ..., num_reserved_ids) by the users. One use case is that a special unknown
+///         word token is used as ID 0. These IDs will have a sampling probability of 0.
+///     - num_shards: A sampler can be used to sample from a subset of the original range
+///         in order to speed up the whole computation through parallelism. This parameter
+///         (together with 'shard') indicates the number of partitions that are being
+///         used in the overall computation.
+///     - shard: A sampler can be used to sample from a subset of the original range
+///         in order to speed up the whole computation through parallelism. This parameter
+///         (together with 'num_shards') indicates the particular partition number of a
+///         sampler op, when partitioning is being used.
+///     - unigrams: A list of unigram counts or probabilities, one per ID in sequential
+///         order. Exactly one of vocab_file and unigrams should be passed to this op.
+///     - seed: If either seed or seed2 are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///     - sampled_candidates: A vector of length num_sampled, in which each element is
+///         the ID of a sampled candidate.
+///     - true_expected_count: A batch_size * num_true matrix, representing
+///         the number of times each candidate is expected to occur in a batch
+///         of sampled candidates. If unique=true, then this is a probability.
+///     - sampled_expected_count: A vector of length num_sampled, for each sampled
+///         candidate representing the number of times the candidate is expected
+///         to occur in a batch of sampled candidates.  If unique=true, then this is a
+///         probability.
+@inlinable @inline(__always)
+public static func fixedUnigramCandidateSampler(
+    trueClasses: Tensor<Int64>,
+    numTrue: Int64,
+    numSampled: Int64,
+    unique: Bool,
+    rangeMax: Int64,
+    vocabFile: String,
+    distortion: Double = 1,
+    numReservedIds: Int64 = 0,
+    numShards: Int64 = 1,
+    shard: Int64 = 0,
+    unigrams: [Double],
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("FixedUnigramCandidateSampler", nOutputs)
+    op.updateAttribute("num_true", numTrue)
+    op.updateAttribute("num_sampled", numSampled)
+    op.updateAttribute("unique", unique)
+    op.updateAttribute("range_max", rangeMax)
+    op.updateAttribute("vocab_file", vocabFile)
+    op.updateAttribute("distortion", distortion)
+    op.updateAttribute("num_reserved_ids", numReservedIds)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard", shard)
+    op.updateAttribute("unigrams", unigrams)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(trueClasses)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+///
+/// Unlike MapDataset, the `f` in FlatMapDataset is expected to return a
+/// Dataset variant, and FlatMapDataset will flatten successive results
+/// into a single Dataset.
+///
+/// - Attr f: A function mapping elements of `input_dataset`, concatenated with
+///     `other_arguments`, to a Dataset variant that contains elements matching
+///     `output_types` and `output_shapes`.
+@inlinable @inline(__always)
+public static func flatMapDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    otherArguments: Targuments,
+    f: (FIn) -> FOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("FlatMapDataset", nOutputs)
+    op.updateAttribute("f", f)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInputList(otherArguments)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func floatInput(
+    _ a: Tensor<Float>
+) {
+  let nOutputs = 0
+    let op = makeOp("FloatInput", nOutputs)
+    op.addInput(a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func floatOutput(
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("FloatOutput", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func floatOutputStringOutput(
+) -> (a: Tensor<Float>, b: StringTensor) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("FloatOutputStringOutput", nOutputs)
+    
+    return op.execute(Int(1), Int(1))
+}
+
+/// Returns element-wise largest integer not greater than x.
+@inlinable @inline(__always)
+public static func floor<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Floor", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns x // y element-wise.
+///
+/// *NOTE*: `FloorDiv` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func floorDiv<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("FloorDiv", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns element-wise remainder of division. When `x < 0` xor `y < 0` is
+///
+/// true, this follows Python semantics in that the result here is consistent
+/// with a flooring divide. E.g. `floor(x / y) * y + mod(x, y) = x`.
+///
+/// *NOTE*: `FloorMod` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func floorMod<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("FloorMod", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func flushSummaryWriter(
+    writer: ResourceHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("FlushSummaryWriter", nOutputs)
+    op.addInput(writer)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func foo1(
+    _ a: Tensor<Float>,
+    _ b: Tensor<Int32>,
+    c: Tensor<Int32>
+) -> (d: Tensor<Float>, e: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("Foo1", nOutputs)
+    op.addInput(a)
+    op.addInput(b)
+    op.addInput(c)
+    return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func foo2(
+    _ a: Tensor<Float>,
+    _ b: StringTensor,
+    c: StringTensor
+) -> (d: Tensor<Float>, e: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("Foo2", nOutputs)
+    op.addInput(a)
+    op.addInput(b)
+    op.addInput(c)
+    return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func foo3(
+    _ a: Tensor<Float>,
+    _ b: StringTensor,
+    c: Tensor<Float>
+) -> (d: Tensor<Float>, e: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("Foo3", nOutputs)
+    op.addInput(a)
+    op.addInput(b)
+    op.addInput(c)
+    return op.execute(Int(1), Int(1))
+}
+
+///   ```python
+///    output = input;
+///    for i in range(start, limit, delta)
+///      output = body(i, output);
+///   ```
+///
+/// - Parameters:
+///     - start: The lower bound. An int32
+///     - limit: The upper bound. An int32
+///     - delta: The increment. An int32
+///     - input: A list of input tensors whose types are T.
+///
+/// - Attrs:
+///     - T: A list of dtypes.
+///     - body:     A function that takes a list of tensors (int32, T) and returns another
+///             list of tensors (T).
+///
+/// - Output output: A list of output tensors whose types are T.
+@inlinable @inline(__always)
+public static func for_<
+    T: TensorArrayProtocol,
+    BodyIn: TensorGroup,
+    BodyOut: TensorGroup
+>(
+    start: Tensor<Int32>,
+    limit: Tensor<Int32>,
+    delta: Tensor<Int32>,
+    _ input: T,
+    body: (BodyIn) -> BodyOut
+) -> T {
+  let nOutputs = Int(input._typeList.count)
+    let op = makeOp("For", nOutputs)
+    op.updateAttribute("T", input._typeList)
+    op.updateAttribute("body", body)
+    op.addInput(start)
+    op.addInput(limit)
+    op.addInput(delta)
+    op.addInputList(input)
+    return op.execute(Int(input._typeList.count))
+}
+
+/// Performs fractional average pooling on the input.
+///
+/// Fractional average pooling is similar to Fractional max pooling in the pooling
+/// region generation step. The only difference is that after pooling regions are
+/// generated, a mean operation is performed instead of a max operation in each
+/// pooling region.
+///
+/// - Parameter value: 4-D with shape `[batch, height, width, channels]`.
+///
+/// - Attrs:
+///     - pooling_ratio: Pooling ratio for each dimension of `value`, currently only
+///         supports row and col dimension and should be >= 1.0. For example, a valid
+///         pooling ratio looks like [1.0, 1.44, 1.73, 1.0]. The first and last elements
+///         must be 1.0 because we don't allow pooling on batch and channels
+///         dimensions. 1.44 and 1.73 are pooling ratio on height and width dimensions
+///         respectively.
+///     - pseudo_random: When set to True, generates the pooling sequence in a
+///         pseudorandom fashion, otherwise, in a random fashion. Check paper [Benjamin
+///         Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071) for
+///         difference between pseudorandom and random.
+///     - overlapping: When set to True, it means when pooling, the values at the boundary
+///         of adjacent pooling cells are used by both cells. For example:
+///
+///         `index  0  1  2  3  4`
+///
+///         `value  20 5  16 3  7`
+///
+///         If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
+///         The result would be [41/3, 26/3] for fractional avg pooling.
+///     - deterministic: When set to True, a fixed pooling region will be used when
+///         iterating over a FractionalAvgPool node in the computation graph. Mainly used
+///         in unit test to make FractionalAvgPool deterministic.
+///     - seed: If either seed or seed2 are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///     - output: output tensor after fractional avg pooling.
+///     - row_pooling_sequence: row pooling sequence, needed to calculate gradient.
+///     - col_pooling_sequence: column pooling sequence, needed to calculate gradient.
+@inlinable @inline(__always)
+public static func fractionalAvgPool<T: Numeric & TensorFlowScalar>(
+    value: Tensor<T>,
+    poolingRatio: [Double],
+    pseudoRandom: Bool = false,
+    overlapping: Bool = false,
+    deterministic: Bool = false,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> (output: Tensor<T>, rowPoolingSequence: Tensor<Int64>, colPoolingSequence: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("FractionalAvgPool", nOutputs)
+    op.updateAttribute("pooling_ratio", poolingRatio)
+    op.updateAttribute("pseudo_random", pseudoRandom)
+    op.updateAttribute("overlapping", overlapping)
+    op.updateAttribute("deterministic", deterministic)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(value)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes gradient of the FractionalAvgPool function.
+///
+/// Unlike FractionalMaxPoolGrad, we don't need to find arg_max for
+/// FractionalAvgPoolGrad, we just need to evenly back-propagate each element of
+/// out_backprop to those indices that form the same pooling cell. Therefore, we
+/// just need to know the shape of original input tensor, instead of the whole
+/// tensor.
+///
+/// - Parameters:
+///     - orig_input_tensor_shape: Original input tensor shape for `fractional_avg_pool`
+///     - out_backprop: 4-D with shape `[batch, height, width, channels]`.  Gradients
+///         w.r.t. the output of `fractional_avg_pool`.
+///     - row_pooling_sequence: row pooling sequence, form pooling region with
+///         col_pooling_sequence.
+///     - col_pooling_sequence: column pooling sequence, form pooling region with
+///         row_pooling sequence.
+///
+/// - Attr overlapping: When set to True, it means when pooling, the values at the boundary
+///     of adjacent pooling cells are used by both cells. For example:
+///
+///     `index  0  1  2  3  4`
+///
+///     `value  20 5  16 3  7`
+///
+///     If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
+///     The result would be [41/3, 26/3] for fractional avg pooling.
+///
+/// - Output output: 4-D.  Gradients w.r.t. the input of `fractional_avg_pool`.
+@inlinable @inline(__always)
+public static func fractionalAvgPoolGrad<T: Numeric & TensorFlowScalar>(
+    origInputTensorShape: Tensor<Int64>,
+    outBackprop: Tensor<T>,
+    rowPoolingSequence: Tensor<Int64>,
+    colPoolingSequence: Tensor<Int64>,
+    overlapping: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("FractionalAvgPoolGrad", nOutputs)
+    op.updateAttribute("overlapping", overlapping)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(origInputTensorShape)
+    op.addInput(outBackprop)
+    op.addInput(rowPoolingSequence)
+    op.addInput(colPoolingSequence)
+    return op.execute(Int(1))
+}
+
+/// Performs fractional max pooling on the input.
+///
+/// Fractional max pooling is slightly different than regular max pooling.  In
+/// regular max pooling, you downsize an input set by taking the maximum value of
+/// smaller N x N subsections of the set (often 2x2), and try to reduce the set by
+/// a factor of N, where N is an integer.  Fractional max pooling, as you might
+/// expect from the word "fractional", means that the overall reduction ratio N
+/// does not have to be an integer.
+///
+/// The sizes of the pooling regions are generated randomly but are fairly uniform.
+/// For example, let's look at the height dimension, and the constraints on the
+/// list of rows that will be pool boundaries.
+///
+/// First we define the following:
+///
+/// 1.  input_row_length : the number of rows from the input set
+/// 2.  output_row_length : which will be smaller than the input
+/// 3.  alpha = input_row_length / output_row_length : our reduction ratio
+/// 4.  K = floor(alpha)
+/// 5.  row_pooling_sequence : this is the result list of pool boundary rows
+///
+/// Then, row_pooling_sequence should satisfy:
+///
+/// 1.  a[0] = 0 : the first value of the sequence is 0
+/// 2.  a[end] = input_row_length : the last value of the sequence is the size
+/// 3.  K <= (a[i+1] - a[i]) <= K+1 : all intervals are K or K+1 size
+/// 4.  length(row_pooling_sequence) = output_row_length+1
+///
+/// For more details on fractional max pooling, see this paper:
+/// [Benjamin Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071)
+///
+/// - Parameter value: 4-D with shape `[batch, height, width, channels]`.
+///
+/// - Attrs:
+///     - pooling_ratio: Pooling ratio for each dimension of `value`, currently only
+///         supports row and col dimension and should be >= 1.0. For example, a valid
+///         pooling ratio looks like [1.0, 1.44, 1.73, 1.0]. The first and last elements
+///         must be 1.0 because we don't allow pooling on batch and channels
+///         dimensions. 1.44 and 1.73 are pooling ratio on height and width dimensions
+///         respectively.
+///     - pseudo_random: When set to True, generates the pooling sequence in a
+///         pseudorandom fashion, otherwise, in a random fashion. Check paper [Benjamin
+///         Graham, Fractional Max-Pooling](http://arxiv.org/abs/1412.6071) for
+///         difference between pseudorandom and random.
+///     - overlapping: When set to True, it means when pooling, the values at the boundary
+///         of adjacent pooling cells are used by both cells. For example:
+///
+///         `index  0  1  2  3  4`
+///
+///         `value  20 5  16 3  7`
+///
+///         If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
+///         The result would be [20, 16] for fractional max pooling.
+///     - deterministic: When set to True, a fixed pooling region will be used when
+///         iterating over a FractionalMaxPool node in the computation graph. Mainly used
+///         in unit test to make FractionalMaxPool deterministic.
+///     - seed: If either seed or seed2 are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///     - output: output tensor after fractional max pooling.
+///     - row_pooling_sequence: row pooling sequence, needed to calculate gradient.
+///     - col_pooling_sequence: column pooling sequence, needed to calculate gradient.
+@inlinable @inline(__always)
+public static func fractionalMaxPool<T: Numeric & TensorFlowScalar>(
+    value: Tensor<T>,
+    poolingRatio: [Double],
+    pseudoRandom: Bool = false,
+    overlapping: Bool = false,
+    deterministic: Bool = false,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> (output: Tensor<T>, rowPoolingSequence: Tensor<Int64>, colPoolingSequence: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("FractionalMaxPool", nOutputs)
+    op.updateAttribute("pooling_ratio", poolingRatio)
+    op.updateAttribute("pseudo_random", pseudoRandom)
+    op.updateAttribute("overlapping", overlapping)
+    op.updateAttribute("deterministic", deterministic)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(value)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes gradient of the FractionalMaxPool function.
+///
+/// - Parameters:
+///     - orig_input: Original input for `fractional_max_pool`
+///     - orig_output: Original output for `fractional_max_pool`
+///     - out_backprop: 4-D with shape `[batch, height, width, channels]`.  Gradients
+///         w.r.t. the output of `fractional_max_pool`.
+///     - row_pooling_sequence: row pooling sequence, form pooling region with
+///         col_pooling_sequence.
+///     - col_pooling_sequence: column pooling sequence, form pooling region with
+///         row_pooling sequence.
+///
+/// - Attr overlapping: When set to True, it means when pooling, the values at the boundary
+///     of adjacent pooling cells are used by both cells. For example:
+///
+///     `index  0  1  2  3  4`
+///
+///     `value  20 5  16 3  7`
+///
+///     If the pooling sequence is [0, 2, 4], then 16, at index 2 will be used twice.
+///     The result would be [20, 16] for fractional max pooling.
+///
+/// - Output output: 4-D.  Gradients w.r.t. the input of `fractional_max_pool`.
+@inlinable @inline(__always)
+public static func fractionalMaxPoolGrad<T: Numeric & TensorFlowScalar>(
+    origInput: Tensor<T>,
+    origOutput: Tensor<T>,
+    outBackprop: Tensor<T>,
+    rowPoolingSequence: Tensor<Int64>,
+    colPoolingSequence: Tensor<Int64>,
+    overlapping: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("FractionalMaxPoolGrad", nOutputs)
+    op.updateAttribute("overlapping", overlapping)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(origInput)
+    op.addInput(origOutput)
+    op.addInput(outBackprop)
+    op.addInput(rowPoolingSequence)
+    op.addInput(colPoolingSequence)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func funcAttr<FIn: TensorGroup,
+    FOut: TensorGroup>(
+    f: (FIn) -> FOut
+) {
+  let nOutputs = 0
+    let op = makeOp("FuncAttr", nOutputs)
+    op.updateAttribute("f", f)
+    op.execute()
+}
+
+/// Batch normalization.
+///
+/// Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
+/// The size of 1D Tensors matches the dimension C of the 4D Tensors.
+///
+/// - Parameters:
+///     - x: A 4D Tensor for input data.
+///     - scale: A 1D Tensor for scaling factor, to scale the normalized x.
+///     - offset: A 1D Tensor for offset, to shift to the normalized x.
+///     - mean: A 1D Tensor for population mean. Used for inference only;
+///         must be empty for training.
+///     - variance: A 1D Tensor for population variance. Used for inference only;
+///         must be empty for training.
+///
+/// - Attrs:
+///     - T: The data type for the elements of input and output Tensors.
+///     - epsilon: A small float number added to the variance of x.
+///     - data_format: The data format for x and y. Either "NHWC" (default) or "NCHW".
+///     - is_training: A bool value to indicate the operation is for training (default)
+///         or inference.
+///
+/// - Outputs:
+///     - y: A 4D Tensor for output data.
+///     - batch_mean: A 1D Tensor for the computed batch mean, to be used by TensorFlow
+///         to compute the running mean.
+///     - batch_variance: A 1D Tensor for the computed batch variance, to be used by
+///         TensorFlow to compute the running variance.
+///     - reserve_space_1: A 1D Tensor for the computed batch mean, to be reused
+///         in the gradient computation.
+///     - reserve_space_2: A 1D Tensor for the computed batch variance (inverted variance
+///         in the cuDNN case), to be reused in the gradient computation.
+@inlinable @inline(__always)
+public static func fusedBatchNorm<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    scale: Tensor<T>,
+    offset: Tensor<T>,
+    mean: Tensor<T>,
+    variance: Tensor<T>,
+    epsilon: Double = 0.0001,
+    dataFormat: DataFormat = .nhwc,
+    isTraining: Bool = true
+) -> (y: Tensor<T>, batchMean: Tensor<T>, batchVariance: Tensor<T>, reserveSpace1: Tensor<T>, reserveSpace2: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("FusedBatchNorm", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("epsilon", epsilon)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("is_training", isTraining)
+    op.addInput(x)
+    op.addInput(scale)
+    op.addInput(offset)
+    op.addInput(mean)
+    op.addInput(variance)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Gradient for batch normalization.
+///
+/// Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
+/// The size of 1D Tensors matches the dimension C of the 4D Tensors.
+///
+/// - Parameters:
+///     - y_backprop: A 4D Tensor for the gradient with respect to y.
+///     - x: A 4D Tensor for input data.
+///     - scale: A 1D Tensor for scaling factor, to scale the normalized x.
+///     - reserve_space_1: When is_training is True, a 1D Tensor for the computed batch
+///         mean to be reused in gradient computation. When is_training is
+///         False, a 1D Tensor for the population mean to be reused in both
+///         1st and 2nd order gradient computation.
+///     - reserve_space_2: When is_training is True, a 1D Tensor for the computed batch
+///         variance (inverted variance in the cuDNN case) to be reused in
+///         gradient computation. When is_training is False, a 1D Tensor
+///         for the population variance to be reused in both 1st and 2nd
+///         order gradient computation.
+///
+/// - Attrs:
+///     - T: The data type for the elements of input and output Tensors.
+///     - epsilon: A small float number added to the variance of x.
+///     - data_format: The data format for y_backprop, x, x_backprop.
+///         Either "NHWC" (default) or "NCHW".
+///     - is_training: A bool value to indicate the operation is for training (default)
+///         or inference.
+///
+/// - Outputs:
+///     - x_backprop: A 4D Tensor for the gradient with respect to x.
+///     - scale_backprop: A 1D Tensor for the gradient with respect to scale.
+///     - offset_backprop: A 1D Tensor for the gradient with respect to offset.
+///     - reserve_space_3: Unused placeholder to match the mean input in FusedBatchNorm.
+///     - reserve_space_4: Unused placeholder to match the variance input
+///         in FusedBatchNorm.
+@inlinable @inline(__always)
+public static func fusedBatchNormGrad<T: FloatingPoint & TensorFlowScalar>(
+    yBackprop: Tensor<T>,
+    _ x: Tensor<T>,
+    scale: Tensor<T>,
+    reserveSpace1: Tensor<T>,
+    reserveSpace2: Tensor<T>,
+    epsilon: Double = 0.0001,
+    dataFormat: DataFormat = .nhwc,
+    isTraining: Bool = true
+) -> (xBackprop: Tensor<T>, scaleBackprop: Tensor<T>, offsetBackprop: Tensor<T>, reserveSpace3: Tensor<T>, reserveSpace4: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("FusedBatchNormGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("epsilon", epsilon)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("is_training", isTraining)
+    op.addInput(yBackprop)
+    op.addInput(x)
+    op.addInput(scale)
+    op.addInput(reserveSpace1)
+    op.addInput(reserveSpace2)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Gradient for batch normalization.
+///
+/// Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
+/// The size of 1D Tensors matches the dimension C of the 4D Tensors.
+///
+/// - Parameters:
+///     - y_backprop: A 4D Tensor for the gradient with respect to y.
+///     - x: A 4D Tensor for input data.
+///     - scale: A 1D Tensor for scaling factor, to scale the normalized x.
+///     - reserve_space_1: When is_training is True, a 1D Tensor for the computed batch
+///         mean to be reused in gradient computation. When is_training is
+///         False, a 1D Tensor for the population mean to be reused in both
+///         1st and 2nd order gradient computation.
+///     - reserve_space_2: When is_training is True, a 1D Tensor for the computed batch
+///         variance (inverted variance in the cuDNN case) to be reused in
+///         gradient computation. When is_training is False, a 1D Tensor
+///         for the population variance to be reused in both 1st and 2nd
+///         order gradient computation.
+///
+/// - Attrs:
+///     - T: The data type for the elements of input and output Tensors.
+///     - U: The data type for the scale, offset, mean, and variance.
+///     - epsilon: A small float number added to the variance of x.
+///     - data_format: The data format for y_backprop, x, x_backprop.
+///         Either "NHWC" (default) or "NCHW".
+///     - is_training: A bool value to indicate the operation is for training (default)
+///         or inference.
+///
+/// - Outputs:
+///     - x_backprop: A 4D Tensor for the gradient with respect to x.
+///     - scale_backprop: A 1D Tensor for the gradient with respect to scale.
+///     - offset_backprop: A 1D Tensor for the gradient with respect to offset.
+///     - reserve_space_3: Unused placeholder to match the mean input in FusedBatchNorm.
+///     - reserve_space_4: Unused placeholder to match the variance input
+///         in FusedBatchNorm.
+@inlinable @inline(__always)
+public static func fusedBatchNormGradV2<
+    T: FloatingPoint & TensorFlowScalar,
+    U: FloatingPoint & TensorFlowScalar
+>(
+    yBackprop: Tensor<T>,
+    _ x: Tensor<T>,
+    scale: Tensor<Float>,
+    reserveSpace1: Tensor<U>,
+    reserveSpace2: Tensor<U>,
+    epsilon: Double = 0.0001,
+    dataFormat: DataFormat = .nhwc,
+    isTraining: Bool = true
+) -> (xBackprop: Tensor<T>, scaleBackprop: Tensor<U>, offsetBackprop: Tensor<U>, reserveSpace3: Tensor<U>, reserveSpace4: Tensor<U>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("FusedBatchNormGradV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("U", U.tensorFlowDataType)
+    op.updateAttribute("epsilon", epsilon)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("is_training", isTraining)
+    op.addInput(yBackprop)
+    op.addInput(x)
+    op.addInput(scale)
+    op.addInput(reserveSpace1)
+    op.addInput(reserveSpace2)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Batch normalization.
+///
+/// Note that the size of 4D Tensors are defined by either "NHWC" or "NCHW".
+/// The size of 1D Tensors matches the dimension C of the 4D Tensors.
+///
+/// - Parameters:
+///     - x: A 4D Tensor for input data.
+///     - scale: A 1D Tensor for scaling factor, to scale the normalized x.
+///     - offset: A 1D Tensor for offset, to shift to the normalized x.
+///     - mean: A 1D Tensor for population mean. Used for inference only;
+///         must be empty for training.
+///     - variance: A 1D Tensor for population variance. Used for inference only;
+///         must be empty for training.
+///
+/// - Attrs:
+///     - T: The data type for the elements of input and output Tensors.
+///     - U: The data type for the scale, offset, mean, and variance.
+///     - epsilon: A small float number added to the variance of x.
+///     - data_format: The data format for x and y. Either "NHWC" (default) or "NCHW".
+///     - is_training: A bool value to indicate the operation is for training (default)
+///         or inference.
+///
+/// - Outputs:
+///     - y: A 4D Tensor for output data.
+///     - batch_mean: A 1D Tensor for the computed batch mean, to be used by TensorFlow
+///         to compute the running mean.
+///     - batch_variance: A 1D Tensor for the computed batch variance, to be used by
+///         TensorFlow to compute the running variance.
+///     - reserve_space_1: A 1D Tensor for the computed batch mean, to be reused
+///         in the gradient computation.
+///     - reserve_space_2: A 1D Tensor for the computed batch variance (inverted variance
+///         in the cuDNN case), to be reused in the gradient computation.
+@inlinable @inline(__always)
+public static func fusedBatchNormV2<
+    T: FloatingPoint & TensorFlowScalar,
+    U: FloatingPoint & TensorFlowScalar
+>(
+    _ x: Tensor<T>,
+    scale: Tensor<U>,
+    offset: Tensor<U>,
+    mean: Tensor<U>,
+    variance: Tensor<U>,
+    epsilon: Double = 0.0001,
+    dataFormat: DataFormat = .nhwc,
+    isTraining: Bool = true
+) -> (y: Tensor<T>, batchMean: Tensor<U>, batchVariance: Tensor<U>, reserveSpace1: Tensor<U>, reserveSpace2: Tensor<U>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("FusedBatchNormV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("U", U.tensorFlowDataType)
+    op.updateAttribute("epsilon", epsilon)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("is_training", isTraining)
+    op.addInput(x)
+    op.addInput(scale)
+    op.addInput(offset)
+    op.addInput(mean)
+    op.addInput(variance)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Performs a padding as a preprocess during a convolution.
+///
+/// Similar to FusedResizeAndPadConv2d, this op allows for an optimized
+/// implementation where the spatial padding transformation stage is fused with the
+/// im2col lookup, but in this case without the bilinear filtering required for
+/// resizing. Fusing the padding prevents the need to write out the intermediate
+/// results as whole tensors, reducing memory pressure, and we can get some latency
+/// gains by merging the transformation calculations.
+/// The data_format attribute for Conv2D isn't supported by this op, and 'NHWC'
+/// order is used instead.
+/// Internally this op uses a single per-graph scratch buffer, which means that it
+/// will block if multiple versions are being run in parallel. This is because this
+/// operator is primarily an optimization to minimize memory usage.
+///
+/// - Parameters:
+///     - input: 4-D with shape `[batch, in_height, in_width, in_channels]`.
+///     - paddings: A two-column matrix specifying the padding sizes. The number of
+///         rows must be the same as the rank of `input`.
+///     - filter: 4-D with shape
+///         `[filter_height, filter_width, in_channels, out_channels]`.
+///
+/// - Attrs:
+///     - strides: 1-D of length 4.  The stride of the sliding window for each dimension
+///         of `input`. Must be in the same order as the dimension specified with format.
+///     - padding: The type of padding algorithm to use.
+@inlinable @inline(__always)
+public static func fusedPadConv2D<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    paddings: Tensor<Int32>,
+    filter: Tensor<T>,
+    mode: Mode5,
+    strides: [Int32],
+    padding: Padding
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("FusedPadConv2D", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("mode", mode.cName)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.addInput(input)
+    op.addInput(paddings)
+    op.addInput(filter)
+    return op.execute(Int(1))
+}
+
+/// Performs a resize and padding as a preprocess during a convolution.
+///
+/// It's often possible to do spatial transformations more efficiently as part of
+/// the packing stage of a convolution, so this op allows for an optimized
+/// implementation where these stages are fused together. This prevents the need to
+/// write out the intermediate results as whole tensors, reducing memory pressure,
+/// and we can get some latency gains by merging the transformation calculations.
+/// The data_format attribute for Conv2D isn't supported by this op, and defaults to
+/// 'NHWC' order.
+/// Internally this op uses a single per-graph scratch buffer, which means that it
+/// will block if multiple versions are being run in parallel. This is because this
+/// operator is primarily an optimization to minimize memory usage.
+///
+/// - Parameters:
+///     - input: 4-D with shape `[batch, in_height, in_width, in_channels]`.
+///     - size: A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+///         new size for the images.
+///     - paddings: A two-column matrix specifying the padding sizes. The number of
+///         rows must be the same as the rank of `input`.
+///     - filter: 4-D with shape
+///         `[filter_height, filter_width, in_channels, out_channels]`.
+///
+/// - Attrs:
+///     - resize_align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
+///         aligned, preserving the values at the corner pixels. Defaults to false.
+///     - strides: 1-D of length 4.  The stride of the sliding window for each dimension
+///         of `input`. Must be in the same order as the dimension specified with format.
+///     - padding: The type of padding algorithm to use.
+@inlinable @inline(__always)
+public static func fusedResizeAndPadConv2D<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    size: Tensor<Int32>,
+    paddings: Tensor<Int32>,
+    filter: Tensor<T>,
+    resizeAlignCorners: Bool = false,
+    mode: Mode5,
+    strides: [Int32],
+    padding: Padding
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("FusedResizeAndPadConv2D", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("resize_align_corners", resizeAlignCorners)
+    op.updateAttribute("mode", mode.cName)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.addInput(input)
+    op.addInput(size)
+    op.addInput(paddings)
+    op.addInput(filter)
+    return op.execute(Int(1))
+}
+
+/// Computes the GRU cell forward propagation for 1 time step.
+///
+/// Args
+///     x: Input to the GRU cell.
+///     h_prev: State input from the previous GRU cell.
+///     w_ru: Weight matrix for the reset and update gate.
+///     w_c: Weight matrix for the cell connection gate.
+///     b_ru: Bias vector for the reset and update gate.
+///     b_c: Bias vector for the cell connection gate.
+///
+/// Returns
+///     r: Output of the reset gate.
+///     u: Output of the update gate.
+///     c: Output of the cell connection gate.
+///     h: Current state of the GRU cell.
+///
+/// Note on notation of the variables:
+///
+/// Concatenation of a and b is represented by a_b
+/// Element-wise dot product of a and b is represented by ab
+/// Element-wise dot product is represented by \circ
+/// Matrix multiplication is represented by *
+///
+/// Biases are initialized with :
+/// `b_ru` - constant_initializer(1.0)
+/// `b_c` - constant_initializer(0.0)
+///
+/// This kernel op implements the following mathematical equations:
+///
+/// ```
+/// x_h_prev = [x, h_prev]
+///
+/// [r_bar u_bar] = x_h_prev * w_ru + b_ru
+///
+/// r = sigmoid(r_bar)
+/// u = sigmoid(u_bar)
+///
+/// h_prevr = h_prev \circ r
+///
+/// x_h_prevr = [x h_prevr]
+///
+/// c_bar = x_h_prevr * w_c + b_c
+/// c = tanh(c_bar)
+///
+/// h = (1-u) \circ c + u \circ h_prev
+/// ```
+@inlinable @inline(__always)
+public static func gRUBlockCell<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    hPrev: Tensor<T>,
+    wRu: Tensor<T>,
+    wC: Tensor<T>,
+    bRu: Tensor<T>,
+    bC: Tensor<T>
+) -> (r: Tensor<T>, u: Tensor<T>, c: Tensor<T>, h: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("GRUBlockCell", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(hPrev)
+    op.addInput(wRu)
+    op.addInput(wC)
+    op.addInput(bRu)
+    op.addInput(bC)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Computes the GRU cell back-propagation for 1 time step.
+///
+/// Args
+///     x: Input to the GRU cell.
+///     h_prev: State input from the previous GRU cell.
+///     w_ru: Weight matrix for the reset and update gate.
+///     w_c: Weight matrix for the cell connection gate.
+///     b_ru: Bias vector for the reset and update gate.
+///     b_c: Bias vector for the cell connection gate.
+///     r: Output of the reset gate.
+///     u: Output of the update gate.
+///     c: Output of the cell connection gate.
+///     d_h: Gradients of the h_new wrt to objective function.
+///
+/// Returns
+///     d_x: Gradients of the x wrt to objective function.
+///     d_h_prev: Gradients of the h wrt to objective function.
+///     d_c_bar Gradients of the c_bar wrt to objective function.
+///     d_r_bar_u_bar Gradients of the r_bar & u_bar wrt to objective function.
+///
+/// This kernel op implements the following mathematical equations:
+///
+/// Note on notation of the variables:
+///
+/// Concatenation of a and b is represented by a_b
+/// Element-wise dot product of a and b is represented by ab
+/// Element-wise dot product is represented by \circ
+/// Matrix multiplication is represented by *
+///
+/// Additional notes for clarity:
+///
+/// `w_ru` can be segmented into 4 different matrices.
+/// ```
+/// w_ru = [w_r_x w_u_x
+///         w_r_h_prev w_u_h_prev]
+/// ```
+/// Similarly, `w_c` can be segmented into 2 different matrices.
+/// ```
+/// w_c = [w_c_x w_c_h_prevr]
+/// ```
+/// Same goes for biases.
+/// ```
+/// b_ru = [b_ru_x b_ru_h]
+/// b_c = [b_c_x b_c_h]
+/// ```
+/// Another note on notation:
+/// ```
+/// d_x = d_x_component_1 + d_x_component_2
+///
+/// where d_x_component_1 = d_r_bar * w_r_x^T + d_u_bar * w_r_x^T
+/// and d_x_component_2 = d_c_bar * w_c_x^T
+///
+/// d_h_prev = d_h_prev_component_1 + d_h_prevr \circ r + d_h \circ u
+/// where d_h_prev_componenet_1 = d_r_bar * w_r_h_prev^T + d_u_bar * w_r_h_prev^T
+/// ```
+///
+/// Mathematics behind the Gradients below:
+/// ```
+/// d_c_bar = d_h \circ (1-u) \circ (1-c \circ c)
+/// d_u_bar = d_h \circ (h-c) \circ u \circ (1-u)
+///
+/// d_r_bar_u_bar = [d_r_bar d_u_bar]
+///
+/// [d_x_component_1 d_h_prev_component_1] = d_r_bar_u_bar * w_ru^T
+///
+/// [d_x_component_2 d_h_prevr] = d_c_bar * w_c^T
+///
+/// d_x = d_x_component_1 + d_x_component_2
+///
+/// d_h_prev = d_h_prev_component_1 + d_h_prevr \circ r + u
+/// ```
+/// Below calculation is performed in the python wrapper for the Gradients
+/// (not in the gradient kernel.)
+/// ```
+/// d_w_ru = x_h_prevr^T * d_c_bar
+///
+/// d_w_c = x_h_prev^T * d_r_bar_u_bar
+///
+/// d_b_ru = sum of d_r_bar_u_bar along axis = 0
+///
+/// d_b_c = sum of d_c_bar along axis = 0
+/// ```
+@inlinable @inline(__always)
+public static func gRUBlockCellGrad<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    hPrev: Tensor<T>,
+    wRu: Tensor<T>,
+    wC: Tensor<T>,
+    bRu: Tensor<T>,
+    bC: Tensor<T>,
+    r: Tensor<T>,
+    u: Tensor<T>,
+    c: Tensor<T>,
+    dH: Tensor<T>
+) -> (dX: Tensor<T>, dHPrev: Tensor<T>, dCBar: Tensor<T>, dRBarUBar: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("GRUBlockCellGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(hPrev)
+    op.addInput(wRu)
+    op.addInput(wC)
+    op.addInput(bRu)
+    op.addInput(bC)
+    op.addInput(r)
+    op.addInput(u)
+    op.addInput(c)
+    op.addInput(dH)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Gather slices from `params` according to `indices`.
+///
+/// `indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
+/// Produces an output tensor with shape `indices.shape + params.shape[1:]` where:
+///
+/// ```python
+///     # Scalar indices
+///     output[:, ..., :] = params[indices, :, ... :]
+///
+///     # Vector indices
+///     output[i, :, ..., :] = params[indices[i], :, ... :]
+///
+///     # Higher rank indices
+///     output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
+/// ```
+///
+/// If `indices` is a permutation and `len(indices) == params.shape[0]` then
+/// this operation will permute `params` accordingly.
+///
+/// `validate_indices`: DEPRECATED. If this operation is assigned to CPU, values in
+/// `indices` are always validated to be within range. If assigned to GPU,
+/// out-of-bound indices result in safe but unspecified behavior, which may include
+/// raising an error.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
+/// </div>
+@inlinable @inline(__always)
+public static func gather<
+    Tparams: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    params: Tensor<Tparams>,
+    indices: Tensor<Tindices>,
+    validateIndices: Bool = true
+) -> Tensor<Tparams> {
+  let nOutputs = Int(1)
+    let op = makeOp("Gather", nOutputs)
+    op.updateAttribute("validate_indices", validateIndices)
+    op.updateAttribute("Tparams", Tparams.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(params)
+    op.addInput(indices)
+    return op.execute(Int(1))
+}
+
+/// Gather slices from `params` into a Tensor with shape specified by `indices`.
+///
+/// `indices` is an K-dimensional integer tensor, best thought of as a
+/// (K-1)-dimensional tensor of indices into `params`, where each element defines a
+/// slice of `params`:
+///
+///     output[\\(i_0, ..., i_{K-2}\\)] = params[indices[\\(i_0, ..., i_{K-2}\\)]]
+///
+/// Whereas in `tf.gather` `indices` defines slices into the first
+/// dimension of `params`, in `tf.gather_nd`, `indices` defines slices into the
+/// first `N` dimensions of `params`, where `N = indices.shape[-1]`.
+///
+/// The last dimension of `indices` can be at most the rank of
+/// `params`:
+///
+///     indices.shape[-1] <= params.rank
+///
+/// The last dimension of `indices` corresponds to elements
+/// (if `indices.shape[-1] == params.rank`) or slices
+/// (if `indices.shape[-1] < params.rank`) along dimension `indices.shape[-1]`
+/// of `params`.  The output tensor has shape
+///
+///     indices.shape[:-1] + params.shape[indices.shape[-1]:]
+///
+/// Note that on CPU, if an out of bound index is found, an error is returned.
+/// On GPU, if an out of bound index is found, a 0 is stored in the
+/// corresponding output value.
+///
+/// Some examples below.
+///
+/// Simple indexing into a matrix:
+///
+/// ```python
+///     indices = [[0, 0], [1, 1]]
+///     params = [['a', 'b'], ['c', 'd']]
+///     output = ['a', 'd']
+/// ```
+///
+/// Slice indexing into a matrix:
+///
+/// ```python
+///     indices = [[1], [0]]
+///     params = [['a', 'b'], ['c', 'd']]
+///     output = [['c', 'd'], ['a', 'b']]
+/// ```
+///
+/// Indexing into a 3-tensor:
+///
+/// ```python
+///     indices = [[1]]
+///     params = [[['a0', 'b0'], ['c0', 'd0']],
+///               [['a1', 'b1'], ['c1', 'd1']]]
+///     output = [[['a1', 'b1'], ['c1', 'd1']]]
+///
+///
+///     indices = [[0, 1], [1, 0]]
+///     params = [[['a0', 'b0'], ['c0', 'd0']],
+///               [['a1', 'b1'], ['c1', 'd1']]]
+///     output = [['c0', 'd0'], ['a1', 'b1']]
+///
+///
+///     indices = [[0, 0, 1], [1, 0, 1]]
+///     params = [[['a0', 'b0'], ['c0', 'd0']],
+///               [['a1', 'b1'], ['c1', 'd1']]]
+///     output = ['b0', 'b1']
+/// ```
+///
+/// Batched indexing into a matrix:
+///
+/// ```python
+///     indices = [[[0, 0]], [[0, 1]]]
+///     params = [['a', 'b'], ['c', 'd']]
+///     output = [['a'], ['b']]
+/// ```
+///
+/// Batched slice indexing into a matrix:
+///
+/// ```python
+///     indices = [[[1]], [[0]]]
+///     params = [['a', 'b'], ['c', 'd']]
+///     output = [[['c', 'd']], [['a', 'b']]]
+/// ```
+///
+/// Batched indexing into a 3-tensor:
+///
+/// ```python
+///     indices = [[[1]], [[0]]]
+///     params = [[['a0', 'b0'], ['c0', 'd0']],
+///               [['a1', 'b1'], ['c1', 'd1']]]
+///     output = [[[['a1', 'b1'], ['c1', 'd1']]],
+///               [[['a0', 'b0'], ['c0', 'd0']]]]
+///
+///     indices = [[[0, 1], [1, 0]], [[0, 0], [1, 1]]]
+///     params = [[['a0', 'b0'], ['c0', 'd0']],
+///               [['a1', 'b1'], ['c1', 'd1']]]
+///     output = [[['c0', 'd0'], ['a1', 'b1']],
+///               [['a0', 'b0'], ['c1', 'd1']]]
+///
+///
+///     indices = [[[0, 0, 1], [1, 0, 1]], [[0, 1, 1], [1, 1, 0]]]
+///     params = [[['a0', 'b0'], ['c0', 'd0']],
+///               [['a1', 'b1'], ['c1', 'd1']]]
+///     output = [['b0', 'b1'], ['d0', 'c1']]
+/// ```
+///
+/// See also `tf.gather` and `tf.batch_gather`.
+///
+/// - Parameters:
+///     - params: The tensor from which to gather values.
+///     - indices: Index tensor.
+///
+/// - Output output: Values from `params` gathered from indices given by `indices`, with
+///     shape `indices.shape[:-1] + params.shape[indices.shape[-1]:]`.
+@inlinable @inline(__always)
+public static func gatherNd<
+    Tparams: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    params: Tensor<Tparams>,
+    indices: Tensor<Tindices>
+) -> Tensor<Tparams> {
+  let nOutputs = Int(1)
+    let op = makeOp("GatherNd", nOutputs)
+    op.updateAttribute("Tparams", Tparams.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(params)
+    op.addInput(indices)
+    return op.execute(Int(1))
+}
+
+/// Gather slices from `params` axis `axis` according to `indices`.
+///
+/// `indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
+/// Produces an output tensor with shape `params.shape[:axis] + indices.shape +
+/// params.shape[axis + 1:]` where:
+///
+/// ```python
+///     # Scalar indices (output is rank(params) - 1).
+///     output[a_0, ..., a_n, b_0, ..., b_n] =
+///       params[a_0, ..., a_n, indices, b_0, ..., b_n]
+///
+///     # Vector indices (output is rank(params)).
+///     output[a_0, ..., a_n, i, b_0, ..., b_n] =
+///       params[a_0, ..., a_n, indices[i], b_0, ..., b_n]
+///
+///     # Higher rank indices (output is rank(params) + rank(indices) - 1).
+///     output[a_0, ..., a_n, i, ..., j, b_0, ... b_n] =
+///       params[a_0, ..., a_n, indices[i, ..., j], b_0, ..., b_n]
+/// ```
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/Gather.png" alt>
+/// </div>
+///
+/// Note that on CPU, if an out of bound index is found, an error is returned.
+/// On GPU, if an out of bound index is found, a 0 is stored in the
+/// corresponding output value.
+///
+/// See also `tf.batch_gather` and `tf.gather_nd`.
+///
+/// - Parameters:
+///     - params: The tensor from which to gather values. Must be at least rank
+///         `axis + 1`.
+///     - indices: Index tensor. Must be in range `[0, params.shape[axis])`.
+///     - axis: The axis in `params` to gather `indices` from. Defaults to the first
+///         dimension. Supports negative indexes.
+///
+/// - Output output: Values from `params` gathered from indices given by `indices`, with
+///     shape `params.shape[:axis] + indices.shape + params.shape[axis + 1:]`.
+@inlinable @inline(__always)
+public static func gatherV2<
+    Tparams: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar,
+    Taxis: BinaryInteger & TensorFlowScalar
+>(
+    params: Tensor<Tparams>,
+    indices: Tensor<Tindices>,
+    axis: Tensor<Taxis>
+) -> Tensor<Tparams> {
+  let nOutputs = Int(1)
+    let op = makeOp("GatherV2", nOutputs)
+    op.updateAttribute("Tparams", Tparams.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("Taxis", Taxis.tensorFlowDataType)
+    op.addInput(params)
+    op.addInput(indices)
+    op.addInput(axis)
+    return op.execute(Int(1))
+}
+
+/// Re-configures the GCS block cache with the new configuration values.
+///
+/// If the values are the same as already configured values, this op is a no-op. If
+/// they are different, the current contents of the block cache is dropped, and a
+/// new block cache is created fresh.
+@inlinable @inline(__always)
+public static func gcsConfigureBlockCache(
+    maxCacheSize: Tensor<UInt64>,
+    blockSize: Tensor<UInt64>,
+    maxStaleness: Tensor<UInt64>
+) {
+  let nOutputs = 0
+    let op = makeOp("GcsConfigureBlockCache", nOutputs)
+    op.addInput(maxCacheSize)
+    op.addInput(blockSize)
+    op.addInput(maxStaleness)
+    op.execute()
+}
+
+/// Configures the credentials used by the GCS client of the local TF runtime.
+///
+/// The json input can be of the format:
+///
+/// 1. Refresh Token:
+/// {
+///   "client_id": "<redacted>",
+///   "client_secret": "<redacted>",
+///   "refresh_token: "<redacted>",
+///   "type": "authorized_user",
+/// }
+///
+/// 2. Service Account:
+/// {
+///   "type": "service_account",
+///   "project_id": "<redacted>",
+///   "private_key_id": "<redacted>",
+///   "private_key": "------BEGIN PRIVATE KEY-----\n<REDACTED>\n-----END PRIVATE KEY------\n",
+///   "client_email": "<REDACTED>@<REDACTED>.iam.gserviceaccount.com",
+///   "client_id": "<REDACTED>",
+///   # Some additional fields elided
+/// }
+///
+/// Note the credentials established through this method are shared across all
+/// sessions run on this runtime.
+///
+/// Note be sure to feed the inputs to this op to ensure the credentials are not
+/// stored in a constant op within the graph that might accidentally be checkpointed
+/// or in other ways be persisted or exfiltrated.
+@inlinable @inline(__always)
+public static func gcsConfigureCredentials(
+    json: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("GcsConfigureCredentials", nOutputs)
+    op.addInput(json)
+    op.execute()
+}
+
+/// Generates serialized partition messages suitable for batch reads.
+///
+/// This op should not be used directly by clients. Instead, the
+/// bigquery_reader_ops.py file defines a clean interface to the reader.
+///
+/// - Attrs:
+///     - project_id: GCP project ID.
+///     - dataset_id: BigQuery Dataset ID.
+///     - table_id: Table to read.
+///     - columns: List of columns to read. Leave empty to read all columns.
+///     - timestamp_millis: Table snapshot timestamp in millis since epoch. Relative
+///         (negative or zero) snapshot times are not allowed. For more details, see
+///         'Table Decorators' in BigQuery docs.
+///     - num_partitions: Number of partitions to split the table into.
+///     - test_end_point: Do not use. For testing purposes only.
+///
+/// - Output partitions: Serialized table partitions.
+@inlinable @inline(__always)
+public static func generateBigQueryReaderPartitions(
+    projectId: String,
+    datasetId: String,
+    tableId: String,
+    columns: [String],
+    timestampMillis: Int64,
+    numPartitions: Int64,
+    testEndPoint: String
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("GenerateBigQueryReaderPartitions", nOutputs)
+    op.updateAttribute("project_id", projectId)
+    op.updateAttribute("dataset_id", datasetId)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("columns", columns)
+    op.updateAttribute("timestamp_millis", timestampMillis)
+    op.updateAttribute("num_partitions", numPartitions)
+    op.updateAttribute("test_end_point", testEndPoint)
+    return op.execute(Int(1))
+}
+
+/// Given a path to new and old vocabulary files, returns a remapping Tensor of
+///
+/// length `num_new_vocab`, where `remapping[i]` contains the row number in the old
+/// vocabulary that corresponds to row `i` in the new vocabulary (starting at line
+/// `new_vocab_offset` and up to `num_new_vocab` entities), or `-1` if entry `i`
+/// in the new vocabulary is not in the old vocabulary.  The old vocabulary is
+/// constrained to the first `old_vocab_size` entries if `old_vocab_size` is not the
+/// default value of -1.
+///
+/// `num_vocab_offset` enables
+/// use in the partitioned variable case, and should generally be set through
+/// examining partitioning info.  The format of the files should be a text file,
+/// with each line containing a single entity within the vocabulary.
+///
+/// For example, with `new_vocab_file` a text file containing each of the following
+/// elements on a single line: `[f0, f1, f2, f3]`, old_vocab_file = [f1, f0, f3],
+/// `num_new_vocab = 3, new_vocab_offset = 1`, the returned remapping would be
+/// `[0, -1, 2]`.
+///
+/// The op also returns a count of how many entries in the new vocabulary
+/// were present in the old vocabulary, which is used to calculate the number of
+/// values to initialize in a weight matrix remapping
+///
+/// This functionality can be used to remap both row vocabularies (typically,
+/// features) and column vocabularies (typically, classes) from TensorFlow
+/// checkpoints.  Note that the partitioning logic relies on contiguous vocabularies
+/// corresponding to div-partitioned variables.  Moreover, the underlying remapping
+/// uses an IndexTable (as opposed to an inexact CuckooTable), so client code should
+/// use the corresponding index_table_from_file() as the FeatureColumn framework
+/// does (as opposed to tf.feature_to_id(), which uses a CuckooTable).
+///
+/// - Parameters:
+///     - new_vocab_file: Path to the new vocab file.
+///     - old_vocab_file: Path to the old vocab file.
+///
+/// - Attrs:
+///     - new_vocab_offset: How many entries into the new vocab file to start reading.
+///     - num_new_vocab: Number of entries in the new vocab file to remap.
+///     - old_vocab_size: Number of entries in the old vocab file to consider.  If -1,
+///         use the entire old vocabulary.
+///
+/// - Outputs:
+///     - remapping: A Tensor of length num_new_vocab where the element at index i
+///         is equal to the old ID that maps to the new ID i.  This element is -1 for any
+///         new ID that is not found in the old vocabulary.
+///     - num_present: Number of new vocab entries found in old vocab.
+@inlinable @inline(__always)
+public static func generateVocabRemapping(
+    newVocabFile: StringTensor,
+    oldVocabFile: StringTensor,
+    newVocabOffset: Int64,
+    numNewVocab: Int64,
+    oldVocabSize: Int64 = -1
+) -> (remapping: Tensor<Int64>, numPresent: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("GenerateVocabRemapping", nOutputs)
+    op.updateAttribute("new_vocab_offset", newVocabOffset)
+    op.updateAttribute("num_new_vocab", numNewVocab)
+    op.updateAttribute("old_vocab_size", oldVocabSize)
+    op.addInput(newVocabFile)
+    op.addInput(oldVocabFile)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Creates a dataset that invokes a function to generate elements.
+@inlinable @inline(__always)
+public static func generatorDataset<
+    InitfuncIn: TensorGroup,
+    InitfuncOut: TensorGroup,
+    NextfuncIn: TensorGroup,
+    NextfuncOut: TensorGroup,
+    FinalizefuncIn: TensorGroup,
+    FinalizefuncOut: TensorGroup,
+    TinitFuncArgs: TensorArrayProtocol,
+    TnextFuncArgs: TensorArrayProtocol,
+    TfinalizeFuncArgs: TensorArrayProtocol
+>(
+    initFuncOtherArgs: TinitFuncArgs,
+    nextFuncOtherArgs: TnextFuncArgs,
+    finalizeFuncOtherArgs: TfinalizeFuncArgs,
+    initFunc: (InitfuncIn) -> InitfuncOut,
+    nextFunc: (NextfuncIn) -> NextfuncOut,
+    finalizeFunc: (FinalizefuncIn) -> FinalizefuncOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("GeneratorDataset", nOutputs)
+    op.updateAttribute("init_func", initFunc)
+    op.updateAttribute("next_func", nextFunc)
+    op.updateAttribute("finalize_func", finalizeFunc)
+    op.updateAttribute("Tinit_func_args", initFuncOtherArgs._typeList)
+    op.updateAttribute("Tnext_func_args", nextFuncOtherArgs._typeList)
+    op.updateAttribute("Tfinalize_func_args", finalizeFuncOtherArgs._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInputList(initFuncOtherArgs)
+    op.addInputList(nextFuncOtherArgs)
+    op.addInputList(finalizeFuncOtherArgs)
+    return op.execute(Int(1))
+}
+
+/// Store the input tensor in the state of the current session.
+///
+/// - Parameter value: The tensor to be stored.
+///
+/// - Output handle: The handle for the tensor stored in the session state, represented
+///     as a string.
+@inlinable @inline(__always)
+public static func getSessionHandle<T: TensorFlowScalar>(
+    value: Tensor<T>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("GetSessionHandle", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(value)
+    return op.execute(Int(1))
+}
+
+/// Store the input tensor in the state of the current session.
+///
+/// - Parameter value: The tensor to be stored.
+///
+/// - Output handle: The handle for the tensor stored in the session state, represented
+///     as a ResourceHandle object.
+@inlinable @inline(__always)
+public static func getSessionHandleV2<T: TensorFlowScalar>(
+    value: Tensor<T>
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("GetSessionHandleV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(value)
+    return op.execute(Int(1))
+}
+
+/// Get the value of the tensor specified by its handle.
+///
+/// - Parameter handle: The handle for a tensor stored in the session state.
+///
+/// - Attr dtype: The type of the output value.
+///
+/// - Output value: The tensor for the given handle.
+@inlinable @inline(__always)
+public static func getSessionTensor<Dtype: TensorFlowScalar>(
+    handle: StringTensor
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("GetSessionTensor", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(handle)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func graphDefVersion(
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("GraphDefVersion", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x > y) element-wise.
+///
+/// *NOTE*: `Greater` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func greater<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("Greater", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x >= y) element-wise.
+///
+/// *NOTE*: `GreaterEqual` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func greaterEqual<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("GreaterEqual", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Gives a guarantee to the TF runtime that the input tensor is a constant.
+///
+/// The runtime is then free to make optimizations based on this.
+///
+/// Only accepts value typed tensors as inputs and rejects resource variable handles
+/// as input.
+///
+/// Returns the input tensor without modification.
+@inlinable @inline(__always)
+public static func guaranteeConst<T: TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("GuaranteeConst", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Convert one or more images from HSV to RGB.
+///
+/// Outputs a tensor of the same shape as the `images` tensor, containing the RGB
+/// value of the pixels. The output is only well defined if the value in `images`
+/// are in `[0,1]`.
+///
+/// See `rgb_to_hsv` for a description of the HSV encoding.
+///
+/// - Parameter images: 1-D or higher rank. HSV data to convert. Last dimension must be size 3.
+///
+/// - Output output: `images` converted to RGB.
+@inlinable @inline(__always)
+public static func hSVToRGB<T: FloatingPoint & TensorFlowScalar>(
+    images: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("HSVToRGB", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(images)
+    return op.execute(Int(1))
+}
+
+/// Creates a non-initialized hash table.
+///
+/// This op creates a hash table, specifying the type of its keys and values.
+/// Before using the table you will have to initialize it.  After initialization the
+/// table will be immutable.
+///
+/// - Attrs:
+///     - container: If non-empty, this table is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this table is shared under the given name across
+///         multiple sessions.
+///     - use_node_name_sharing: If true and shared_name is empty, the table is shared
+///         using the node name.
+///     - key_dtype: Type of the table keys.
+///     - value_dtype: Type of the table values.
+///
+/// - Output table_handle: Handle to a table.
+@inlinable @inline(__always)
+public static func hashTableV2(
+    container: String,
+    sharedName: String,
+    useNodeNameSharing: Bool = false,
+    keyDtype: TensorDataType,
+    valueDtype: TensorDataType
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("HashTableV2", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("use_node_name_sharing", useNodeNameSharing)
+    op.updateAttribute("key_dtype", keyDtype)
+    op.updateAttribute("value_dtype", valueDtype)
+    return op.execute(Int(1))
+}
+
+/// Return histogram of values.
+///
+/// Given the tensor `values`, this operation returns a rank 1 histogram counting
+/// the number of entries in `values` that fall into every bin.  The bins are
+/// equal width and determined by the arguments `value_range` and `nbins`.
+///
+/// ```python
+/// # Bins will be:  (-inf, 1), [1, 2), [2, 3), [3, 4), [4, inf)
+/// nbins = 5
+/// value_range = [0.0, 5.0]
+/// new_values = [-1.0, 0.0, 1.5, 2.0, 5.0, 15]
+///
+/// with tf.get_default_session() as sess:
+///   hist = tf.histogram_fixed_width(new_values, value_range, nbins=5)
+///   variables.global_variables_initializer().run()
+///   sess.run(hist) => [2, 1, 1, 0, 2]
+/// ```
+///
+/// - Parameters:
+///     - values: Numeric `Tensor`.
+///     - value_range: Shape [2] `Tensor` of same `dtype` as `values`.
+///         values <= value_range[0] will be mapped to hist[0],
+///         values >= value_range[1] will be mapped to hist[-1].
+///     - nbins: Scalar `int32 Tensor`.  Number of histogram bins.
+///
+/// - Output out: A 1-D `Tensor` holding histogram of values.
+@inlinable @inline(__always)
+public static func histogramFixedWidth<
+    T: Numeric & TensorFlowScalar,
+    Dtype: BinaryInteger & TensorFlowScalar
+>(
+    _ values: Tensor<T>,
+    valueRange: Tensor<T>,
+    nbins: Tensor<Int32>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("HistogramFixedWidth", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(values)
+    op.addInput(valueRange)
+    op.addInput(nbins)
+    return op.execute(Int(1))
+}
+
+/// Outputs a `Summary` protocol buffer with a histogram.
+///
+/// The generated
+/// [`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto)
+/// has one summary value containing a histogram for `values`.
+///
+/// This op reports an `InvalidArgument` error if any value is not finite.
+///
+/// - Parameters:
+///     - tag: Scalar.  Tag to use for the `Summary.Value`.
+///     - values: Any shape. Values to use to build the histogram.
+///
+/// - Output summary: Scalar. Serialized `Summary` protocol buffer.
+@inlinable @inline(__always)
+public static func histogramSummary<T: Numeric & TensorFlowScalar>(
+    tag: StringTensor,
+    _ values: Tensor<T>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("HistogramSummary", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(tag)
+    op.addInput(values)
+    return op.execute(Int(1))
+}
+
+/// Inverse fast Fourier transform.
+///
+/// Computes the inverse 1-dimensional discrete Fourier transform over the
+/// inner-most dimension of `input`.
+///
+/// - Parameter input: A complex tensor.
+///
+/// - Output output: A complex tensor of the same shape as `input`. The inner-most
+///       dimension of `input` is replaced with its inverse 1D Fourier transform.
+///
+///     @compatibility(numpy)
+///     Equivalent to np.fft.ifft
+///     @end_compatibility
+@inlinable @inline(__always)
+public static func iFFT<Tcomplex: TensorFlowScalar>(
+    _ input: Tensor<Tcomplex>
+) -> Tensor<Tcomplex> {
+  let nOutputs = Int(1)
+    let op = makeOp("IFFT", nOutputs)
+    op.updateAttribute("Tcomplex", Tcomplex.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Inverse 2D fast Fourier transform.
+///
+/// Computes the inverse 2-dimensional discrete Fourier transform over the
+/// inner-most 2 dimensions of `input`.
+///
+/// - Parameter input: A complex tensor.
+///
+/// - Output output: A complex tensor of the same shape as `input`. The inner-most 2
+///       dimensions of `input` are replaced with their inverse 2D Fourier transform.
+///
+///     @compatibility(numpy)
+///     Equivalent to np.fft.ifft2
+///     @end_compatibility
+@inlinable @inline(__always)
+public static func iFFT2D<Tcomplex: TensorFlowScalar>(
+    _ input: Tensor<Tcomplex>
+) -> Tensor<Tcomplex> {
+  let nOutputs = Int(1)
+    let op = makeOp("IFFT2D", nOutputs)
+    op.updateAttribute("Tcomplex", Tcomplex.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Inverse 3D fast Fourier transform.
+///
+/// Computes the inverse 3-dimensional discrete Fourier transform over the
+/// inner-most 3 dimensions of `input`.
+///
+/// - Parameter input: A complex64 tensor.
+///
+/// - Output output: A complex64 tensor of the same shape as `input`. The inner-most 3
+///       dimensions of `input` are replaced with their inverse 3D Fourier transform.
+///
+///     @compatibility(numpy)
+///     Equivalent to np.fft.ifftn with 3 dimensions.
+///     @end_compatibility
+@inlinable @inline(__always)
+public static func iFFT3D<Tcomplex: TensorFlowScalar>(
+    _ input: Tensor<Tcomplex>
+) -> Tensor<Tcomplex> {
+  let nOutputs = Int(1)
+    let op = makeOp("IFFT3D", nOutputs)
+    op.updateAttribute("Tcomplex", Tcomplex.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Return a tensor with the same shape and contents as the input tensor or value.
+@inlinable @inline(__always)
+public static func identity<T: TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Identity", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Returns a list of tensors with the same shapes and contents as the input
+///
+/// tensors.
+///
+/// This op can be used to override the gradient for complicated functions. For
+/// example, suppose y = f(x) and we wish to apply a custom function g for backprop
+/// such that dx = g(dy). In Python,
+///
+/// ```python
+/// with tf.get_default_graph().gradient_override_map(
+///     {'IdentityN': 'OverrideGradientWithG'}):
+///   y, _ = identity_n([f(x), x])
+///
+/// @tf.RegisterGradient('OverrideGradientWithG')
+/// def ApplyG(op, dy, _):
+///   return [None, g(dy)]  # Do not backprop to f(x).
+/// ```
+@inlinable @inline(__always)
+public static func identityN<T: TensorArrayProtocol>(
+    _ input: T
+) -> T {
+  let nOutputs = Int(input._typeList.count)
+    let op = makeOp("IdentityN", nOutputs)
+    op.updateAttribute("T", input._typeList)
+    op.addInputList(input)
+    return op.execute(Int(input._typeList.count))
+}
+
+/// A Reader that outputs the queued work as both the key and value.
+///
+/// To use, enqueue strings in a Queue.  ReaderRead will take the front
+/// work string and output (work, work).
+///
+/// - Attrs:
+///     - container: If non-empty, this reader is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this reader is named in the given bucket
+///         with this shared_name. Otherwise, the node name is used instead.
+///
+/// - Output reader_handle: The handle to reference the Reader.
+@inlinable @inline(__always)
+public static func identityReaderV2(
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("IdentityReaderV2", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// output = cond ? then_branch(input) : else_branch(input)
+///
+/// - Parameters:
+///     - cond:       A Tensor. If the tensor is a scalar of non-boolean type, the
+///               scalar is converted to a boolean according to the
+///               following rule: if the scalar is a numerical value, non-zero means
+///               `True` and zero means False; if the scalar is a string, non-empty
+///               means `True` and empty means `False`. If the tensor is not a scalar,
+///               being empty means False and being non-empty means True.
+///     - input: A list of input tensors.
+///
+/// - Attrs:
+///     - Tin: A list of input types.
+///     - Tout: A list of output types.
+///     - then_branch:       A function that takes 'inputs' and returns a list of tensors, whose
+///               types are the same as what else_branch returns.
+///     - else_branch:     A function that takes 'inputs' and returns a list of tensors, whose
+///             types are the same as what then_branch returns.
+///
+/// - Output output: A list of return values.
+@inlinable @inline(__always)
+public static func if_<
+    Tcond: TensorFlowScalar,
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    ThenbranchIn: TensorGroup,
+    ThenbranchOut: TensorGroup,
+    ElsebranchIn: TensorGroup,
+    ElsebranchOut: TensorGroup
+>(
+    cond: Tensor<Tcond>,
+    _ input: Tin,
+    thenBranch: (ThenbranchIn) -> ThenbranchOut,
+    elseBranch: (ElsebranchIn) -> ElsebranchOut,
+    outputShapes: [TensorShape?]
+) -> Tout {
+  let nOutputs = Int(Tout._typeList.count)
+    let op = makeOp("If", nOutputs)
+    op.updateAttribute("Tcond", Tcond.tensorFlowDataType)
+    op.updateAttribute("Tin", input._typeList)
+    op.updateAttribute("Tout", Tout._typeList)
+    op.updateAttribute("then_branch", thenBranch)
+    op.updateAttribute("else_branch", elseBranch)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(cond)
+    op.addInputList(input)
+    return op.execute(Int(Tout._typeList.count))
+}
+
+/// Compute the lower regularized incomplete Gamma function `P(a, x)`.
+///
+/// The lower regularized incomplete Gamma function is defined as:
+///
+///
+/// \\(P(a, x) = gamma(a, x) / Gamma(a) = 1 - Q(a, x)\\)
+///
+/// where
+///
+/// \\(gamma(a, x) = \\int_{0}^{x} t^{a-1} exp(-t) dt\\)
+///
+/// is the lower incomplete Gamma function.
+///
+/// Note, above `Q(a, x)` (`Igammac`) is the upper regularized complete
+/// Gamma function.
+@inlinable @inline(__always)
+public static func igamma<T: FloatingPoint & TensorFlowScalar>(
+    _ a: Tensor<T>,
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Igamma", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient of `igamma(a, x)` wrt `a`.
+@inlinable @inline(__always)
+public static func igammaGradA<T: FloatingPoint & TensorFlowScalar>(
+    _ a: Tensor<T>,
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("IgammaGradA", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Compute the upper regularized incomplete Gamma function `Q(a, x)`.
+///
+/// The upper regularized incomplete Gamma function is defined as:
+///
+/// \\(Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)\\)
+///
+/// where
+///
+/// \\(Gamma(a, x) = int_{x}^{\infty} t^{a-1} exp(-t) dt\\)
+///
+/// is the upper incomplete Gama function.
+///
+/// Note, above `P(a, x)` (`Igamma`) is the lower regularized complete
+/// Gamma function.
+@inlinable @inline(__always)
+public static func igammac<T: FloatingPoint & TensorFlowScalar>(
+    _ a: Tensor<T>,
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Igammac", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns the imaginary part of a complex number.
+///
+/// Given a tensor `input` of complex numbers, this operation returns a tensor of
+/// type `float` that is the imaginary part of each element in `input`. All
+/// elements in `input` must be complex numbers of the form \\(a + bj\\), where *a*
+/// is the real part and *b* is the imaginary part returned by this operation.
+///
+/// For example:
+///
+/// ```
+/// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
+/// tf.imag(input) ==> [4.75, 5.75]
+/// ```
+@inlinable @inline(__always)
+public static func imag<
+    T: TensorFlowScalar,
+    Tout: FloatingPoint & TensorFlowScalar
+>(
+    _ input: Tensor<T>
+) -> Tensor<Tout> {
+  let nOutputs = Int(1)
+    let op = makeOp("Imag", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tout", Tout.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Returns immutable tensor from memory region.
+///
+/// The current implementation memmaps the tensor from a file.
+///
+/// - Attrs:
+///     - dtype: Type of the returned tensor.
+///     - shape: Shape of the returned tensor.
+///     - memory_region_name: Name of readonly memory region used by the tensor, see
+///         NewReadOnlyMemoryRegionFromFile in tensorflow::Env.
+@inlinable @inline(__always)
+public static func immutableConst<Dtype: TensorFlowScalar>(
+    shape: TensorShape?,
+    memoryRegionName: String
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("ImmutableConst", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape", shape)
+    op.updateAttribute("memory_region_name", memoryRegionName)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func importEvent(
+    writer: ResourceHandle,
+    event: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("ImportEvent", nOutputs)
+    op.addInput(writer)
+    op.addInput(event)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func inPolymorphicTwice<T: TensorFlowScalar>(
+    _ a: [Tensor<T>],
+    _ b: [Tensor<T>]
+) {
+  let nOutputs = 0
+    let op = makeOp("InPolymorphicTwice", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("N", a.count)
+    op.updateAttribute("M", b.count)
+    op.addInputList(a)
+    op.addInputList(b)
+    op.execute()
+}
+
+/// Says whether the targets are in the top `K` predictions.
+///
+/// This outputs a `batch_size` bool array, an entry `out[i]` is `true` if the
+/// prediction for the target class is among the top `k` predictions among
+/// all predictions for example `i`. Note that the behavior of `InTopK` differs
+/// from the `TopK` op in its handling of ties; if multiple classes have the
+/// same prediction value and straddle the top-`k` boundary, all of those
+/// classes are considered to be in the top `k`.
+///
+/// More formally, let
+///
+///   \\(predictions_i\\) be the predictions for all classes for example `i`,
+///   \\(targets_i\\) be the target class for example `i`,
+///   \\(out_i\\) be the output for example `i`,
+///
+/// $$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
+///
+/// - Parameters:
+///     - predictions: A `batch_size` x `classes` tensor.
+///     - targets: A `batch_size` vector of class ids.
+///
+/// - Attr k: Number of top elements to look at for computing precision.
+///
+/// - Output precision: Computed Precision at `k` as a `bool Tensor`.
+@inlinable @inline(__always)
+public static func inTopK<T: BinaryInteger & TensorFlowScalar>(
+    predictions: Tensor<Float>,
+    targets: Tensor<T>,
+    k: Int64
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("InTopK", nOutputs)
+    op.updateAttribute("k", k)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(predictions)
+    op.addInput(targets)
+    return op.execute(Int(1))
+}
+
+/// Says whether the targets are in the top `K` predictions.
+///
+/// This outputs a `batch_size` bool array, an entry `out[i]` is `true` if the
+/// prediction for the target class is among the top `k` predictions among
+/// all predictions for example `i`. Note that the behavior of `InTopK` differs
+/// from the `TopK` op in its handling of ties; if multiple classes have the
+/// same prediction value and straddle the top-`k` boundary, all of those
+/// classes are considered to be in the top `k`.
+///
+/// More formally, let
+///
+///   \\(predictions_i\\) be the predictions for all classes for example `i`,
+///   \\(targets_i\\) be the target class for example `i`,
+///   \\(out_i\\) be the output for example `i`,
+///
+/// $$out_i = predictions_{i, targets_i} \in TopKIncludingTies(predictions_i)$$
+///
+/// - Parameters:
+///     - predictions: A `batch_size` x `classes` tensor.
+///     - targets: A `batch_size` vector of class ids.
+///     - k: Number of top elements to look at for computing precision.
+///
+/// - Output precision: Computed precision at `k` as a `bool Tensor`.
+@inlinable @inline(__always)
+public static func inTopKV2<T: BinaryInteger & TensorFlowScalar>(
+    predictions: Tensor<Float>,
+    targets: Tensor<T>,
+    k: Tensor<T>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("InTopKV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(predictions)
+    op.addInput(targets)
+    op.addInput(k)
+    return op.execute(Int(1))
+}
+
+/// A placeholder op for a value that will be fed into the computation.
+///
+/// - Attrs:
+///     - dtype: The type of elements in the tensor.
+///     - shape: The shape of the tensor.
+///
+/// - Output output: A tensor that will be provided using the infeed mechanism.
+@inlinable @inline(__always)
+public static func infeedDequeue<Dtype: TensorFlowScalar>(
+    shape: TensorShape?
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("InfeedDequeue", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape", shape)
+    return op.execute(Int(1))
+}
+
+/// Fetches multiple values from infeed as an XLA tuple.
+///
+/// - Attrs:
+///     - dtypes: The element types of each element in `outputs`.
+///     - shapes: The shapes of each tensor in `outputs`.
+///
+/// - Output outputs: A list of tensors that will be provided using the infeed mechanism.
+@inlinable @inline(__always)
+public static func infeedDequeueTuple<Dtypes: TensorGroup>(
+    shapes: [TensorShape?]
+) -> Dtypes {
+  let nOutputs = Int(Dtypes._typeList.count)
+    let op = makeOp("InfeedDequeueTuple", nOutputs)
+    op.updateAttribute("dtypes", Dtypes._typeList)
+    op.updateAttribute("shapes", shapes)
+    return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// An op which feeds a single Tensor value into the computation.
+///
+/// - Parameter input: A tensor that will be provided using the infeed mechanism.
+///
+/// - Attrs:
+///     - dtype: The type of elements in the tensor.
+///     - shape: The shape of the tensor.
+///     - layout: A vector holding the requested layout in minor-to-major sequence.
+///         If a layout attribute is passed, but its values are all -1, the layout will
+///         be computed by the infeed operation.
+///     - device_ordinal: The TPU device to use. This should be -1 when the Op
+///         is running on a TPU device, and >= 0 when the Op is running on the CPU
+///         device.
+@inlinable @inline(__always)
+public static func infeedEnqueue<Dtype: TensorFlowScalar>(
+    _ input: Tensor<Dtype>,
+    shape: TensorShape?,
+    layout: [Int32],
+    deviceOrdinal: Int64 = -1
+) {
+  let nOutputs = 0
+    let op = makeOp("InfeedEnqueue", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape", shape)
+    op.updateAttribute("layout", layout)
+    op.updateAttribute("device_ordinal", deviceOrdinal)
+    op.addInput(input)
+    op.execute()
+}
+
+/// An op which enqueues prelinearized buffer into TPU infeed.
+///
+/// - Parameter input: A variant tensor representing linearized output.
+///
+/// - Attr device_ordinal: The TPU device to use. This should be -1 when the Op is running on a TPU device
+///     and = 0 when the Op is running on the CPU device.
+@inlinable @inline(__always)
+public static func infeedEnqueuePrelinearizedBuffer(
+    _ input: VariantHandle,
+    deviceOrdinal: Int64 = -1
+) {
+  let nOutputs = 0
+    let op = makeOp("InfeedEnqueuePrelinearizedBuffer", nOutputs)
+    op.updateAttribute("device_ordinal", deviceOrdinal)
+    op.addInput(input)
+    op.execute()
+}
+
+/// Feeds multiple Tensor values into the computation as an XLA tuple.
+///
+/// - Parameter inputs: A list of tensors that will be provided using the infeed mechanism.
+///
+/// - Attrs:
+///     - dtypes: The element types of each element in `inputs`.
+///     - shapes: The shapes of each tensor in `inputs`.
+///     - layouts: A vector holding the requested layout in minor-to-major sequence for
+///         all the tuple shapes, in the order the shapes appear in the "shapes" input.
+///         The layout elements for a sub-shape can be set to -1, in which case the
+///         corresponding layout will be computed by the infeed operation.
+///     - device_ordinal: The TPU device to use. This should be -1 when the Op
+///         is running on a TPU device, and >= 0 when the Op is running on the CPU
+///         device.
+@inlinable @inline(__always)
+public static func infeedEnqueueTuple<Dtypes: TensorArrayProtocol>(
+    inputs: Dtypes,
+    shapes: [TensorShape?],
+    layouts: [Int32],
+    deviceOrdinal: Int64 = -1
+) {
+  let nOutputs = 0
+    let op = makeOp("InfeedEnqueueTuple", nOutputs)
+    op.updateAttribute("dtypes", inputs._typeList)
+    op.updateAttribute("shapes", shapes)
+    op.updateAttribute("layouts", layouts)
+    op.updateAttribute("device_ordinal", deviceOrdinal)
+    op.addInputList(inputs)
+    op.execute()
+}
+
+/// Initializes a table from a text file.
+///
+/// It inserts one key-value pair into the table for each line of the file.
+/// The key and value is extracted from the whole line content, elements from the
+/// split line based on `delimiter` or the line number (starting from zero).
+/// Where to extract the key and value from a line is specified by `key_index` and
+/// `value_index`.
+///
+/// - A value of -1 means use the line number(starting from zero), expects `int64`.
+/// - A value of -2 means use the whole line content, expects `string`.
+/// - A value >= 0 means use the index (starting at zero) of the split line based
+///   on `delimiter`.
+///
+/// - Parameters:
+///     - table_handle: Handle to a table which will be initialized.
+///     - filename: Filename of a vocabulary text file.
+///
+/// - Attrs:
+///     - key_index: Column index in a line to get the table `key` values from.
+///     - value_index: Column index that represents information of a line to get the table
+///         `value` values from.
+///     - vocab_size: Number of elements of the file, use -1 if unknown.
+///     - delimiter: Delimiter to separate fields in a line.
+@inlinable @inline(__always)
+public static func initializeTableFromTextFileV2(
+    tableHandle: ResourceHandle,
+    filename: StringTensor,
+    keyIndex: Int64,
+    valueIndex: Int64,
+    vocabSize: Int64 = -1,
+    delimiter: String = "\t"
+) {
+  let nOutputs = 0
+    let op = makeOp("InitializeTableFromTextFileV2", nOutputs)
+    op.updateAttribute("key_index", keyIndex)
+    op.updateAttribute("value_index", valueIndex)
+    op.updateAttribute("vocab_size", vocabSize)
+    op.updateAttribute("delimiter", delimiter)
+    op.addInput(tableHandle)
+    op.addInput(filename)
+    op.execute()
+}
+
+/// Table initializer that takes two tensors for keys and values respectively.
+///
+/// - Parameters:
+///     - table_handle: Handle to a table which will be initialized.
+///     - keys: Keys of type Tkey.
+///     - values: Values of type Tval.
+@inlinable @inline(__always)
+public static func initializeTableV2<
+    Tkey: TensorFlowScalar,
+    Tval: TensorFlowScalar
+>(
+    tableHandle: ResourceHandle,
+    keys: Tensor<Tkey>,
+    _ values: Tensor<Tval>
+) {
+  let nOutputs = 0
+    let op = makeOp("InitializeTableV2", nOutputs)
+    op.updateAttribute("Tkey", Tkey.tensorFlowDataType)
+    op.updateAttribute("Tval", Tval.tensorFlowDataType)
+    op.addInput(tableHandle)
+    op.addInput(keys)
+    op.addInput(values)
+    op.execute()
+}
+
+///     Adds v into specified rows of x.
+///
+///     Computes y = x; y[i, :] += v; return y.
+///
+/// - Parameters:
+///     - x: A `Tensor` of type T.
+///     - i: A vector. Indices into the left-most dimension of `x`.
+///     - v: A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
+///
+/// - Output y: A `Tensor` of type T. An alias of `x`. The content of `y` is undefined if there are duplicates in `i`.
+@inlinable @inline(__always)
+public static func inplaceAdd<T: TensorFlowScalar>(
+    _ x: Tensor<T>,
+    i: Tensor<Int32>,
+    v: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("InplaceAdd", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(i)
+    op.addInput(v)
+    return op.execute(Int(1))
+}
+
+///     Subtracts `v` into specified rows of `x`.
+///
+///     Computes y = x; y[i, :] -= v; return y.
+///
+/// - Parameters:
+///     - x: A `Tensor` of type T.
+///     - i: A vector. Indices into the left-most dimension of `x`.
+///     - v: A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
+///
+/// - Output y: A `Tensor` of type T. An alias of `x`. The content of `y` is undefined if there are duplicates in `i`.
+@inlinable @inline(__always)
+public static func inplaceSub<T: TensorFlowScalar>(
+    _ x: Tensor<T>,
+    i: Tensor<Int32>,
+    v: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("InplaceSub", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(i)
+    op.addInput(v)
+    return op.execute(Int(1))
+}
+
+///     Updates specified rows with values in `v`.
+///
+///     Computes `x[i, :] = v; return x`.
+///
+/// - Parameters:
+///     - x: A tensor of type `T`.
+///     - i: A vector. Indices into the left-most dimension of `x`.
+///     - v: A `Tensor` of type T. Same dimension sizes as x except the first dimension, which must be the same as i's size.
+///
+/// - Output y: A `Tensor` of type T. An alias of `x`. The content of `y` is undefined if there are duplicates in `i`.
+@inlinable @inline(__always)
+public static func inplaceUpdate<T: TensorFlowScalar>(
+    _ x: Tensor<T>,
+    i: Tensor<Int32>,
+    v: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("InplaceUpdate", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(i)
+    op.addInput(v)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func int64Output(
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("Int64Output", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func intAttr(
+    foo: Int64 = 1
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("IntAttr", nOutputs)
+    op.updateAttribute("foo", foo)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func intInput(
+    _ a: Tensor<Int32>
+) {
+  let nOutputs = 0
+    let op = makeOp("IntInput", nOutputs)
+    op.addInput(a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func intInputFloatInput(
+    _ a: Tensor<Int32>,
+    _ b: Tensor<Float>
+) {
+  let nOutputs = 0
+    let op = makeOp("IntInputFloatInput", nOutputs)
+    op.addInput(a)
+    op.addInput(b)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func intInputIntOutput(
+    _ a: Tensor<Int32>
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("IntInputIntOutput", nOutputs)
+    op.addInput(a)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func intOutput(
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("IntOutput", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func intOutputFloatOutput(
+) -> (a: Tensor<Int32>, b: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("IntOutputFloatOutput", nOutputs)
+    
+    return op.execute(Int(1), Int(1))
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+///
+/// Unlike MapDataset, the `f` in InterleaveDataset is expected to return
+/// a Dataset variant, and InterleaveDataset will flatten successive
+/// results into a single Dataset. Unlike FlatMapDataset,
+/// InterleaveDataset will interleave sequences of up to `block_length`
+/// consecutive elements from `cycle_length` input elements.
+///
+/// - Attr f: A function mapping elements of `input_dataset`, concatenated with
+///     `other_arguments`, to a Dataset variant that contains elements matching
+///     `output_types` and `output_shapes`.
+@inlinable @inline(__always)
+public static func interleaveDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    otherArguments: Targuments,
+    cycleLength: Tensor<Int64>,
+    blockLength: Tensor<Int64>,
+    f: (FIn) -> FOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("InterleaveDataset", nOutputs)
+    op.updateAttribute("f", f)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInputList(otherArguments)
+    op.addInput(cycleLength)
+    op.addInput(blockLength)
+    return op.execute(Int(1))
+}
+
+/// Computes the reciprocal of x element-wise.
+///
+/// I.e., \\(y = 1 / x\\).
+@inlinable @inline(__always)
+public static func inv<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Inv", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient for the inverse of `x` wrt its input.
+///
+/// Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy`
+/// is the corresponding input gradient.
+@inlinable @inline(__always)
+public static func invGrad<T: FloatingPoint & TensorFlowScalar>(
+    _ y: Tensor<T>,
+    dy: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("InvGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(y)
+    op.addInput(dy)
+    return op.execute(Int(1))
+}
+
+/// Flips all bits elementwise.
+///
+/// The result will have exactly those bits set, that are not set in `x`. The
+/// computation is performed on the underlying representation of x.
+@inlinable @inline(__always)
+public static func invert<T: BinaryInteger & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Invert", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the inverse permutation of a tensor.
+///
+/// This operation computes the inverse of an index permutation. It takes a 1-D
+/// integer tensor `x`, which represents the indices of a zero-based array, and
+/// swaps each value with its index position. In other words, for an output tensor
+/// `y` and an input tensor `x`, this operation computes the following:
+///
+/// `y[x[i]] = i for i in [0, 1, ..., len(x) - 1]`
+///
+/// The values must include 0. There can be no duplicate values or negative values.
+///
+/// For example:
+///
+/// ```
+/// # tensor `x` is [3, 4, 0, 2, 1]
+/// invert_permutation(x) ==> [2, 4, 3, 0, 1]
+/// ```
+///
+/// - Parameter x: 1-D.
+///
+/// - Output y: 1-D.
+@inlinable @inline(__always)
+public static func invertPermutation<T: BinaryInteger & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("InvertPermutation", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Checks whether a tree ensemble has been initialized.
+///
+/// - Parameter tree_ensemble_handle: Handle to the tree ensemble resouce.
+///
+/// - Output is_initialized: output boolean on whether it is initialized or not.
+@inlinable @inline(__always)
+public static func isBoostedTreesEnsembleInitialized(
+    treeEnsembleHandle: ResourceHandle
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("IsBoostedTreesEnsembleInitialized", nOutputs)
+    op.addInput(treeEnsembleHandle)
+    return op.execute(Int(1))
+}
+
+/// Checks whether a quantile stream has been initialized.
+///
+/// An Op that checks if quantile stream resource is initialized.
+///
+/// - Parameter quantile_stream_resource_handle: resource; The reference to quantile stream resource handle.
+///
+/// - Output is_initialized: bool; True if the resource is initialized, False otherwise.
+@inlinable @inline(__always)
+public static func isBoostedTreesQuantileStreamResourceInitialized(
+    quantileStreamResourceHandle: ResourceHandle
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("IsBoostedTreesQuantileStreamResourceInitialized", nOutputs)
+    op.addInput(quantileStreamResourceHandle)
+    return op.execute(Int(1))
+}
+
+/// Returns which elements of x are finite.
+///
+/// @compatibility(numpy)
+/// Equivalent to np.isfinite
+/// @end_compatibility
+@inlinable @inline(__always)
+public static func isFinite<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("IsFinite", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns which elements of x are Inf.
+///
+/// @compatibility(numpy)
+/// Equivalent to np.isinf
+/// @end_compatibility
+@inlinable @inline(__always)
+public static func isInf<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("IsInf", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns which elements of x are NaN.
+///
+/// @compatibility(numpy)
+/// Equivalent to np.isnan
+/// @end_compatibility
+@inlinable @inline(__always)
+public static func isNan<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("IsNan", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// A container for an iterator resource.
+///
+/// - Output handle: A handle to the iterator that can be passed to a "MakeIterator"
+///     or "IteratorGetNext" op.
+@inlinable @inline(__always)
+public static func iterator(
+    sharedName: String,
+    container: String,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("Iterator", nOutputs)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("container", container)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    return op.execute(Int(1))
+}
+
+/// Converts the given string representing a handle to an iterator to a resource.
+///
+/// - Parameter string_handle: A string representation of the given handle.
+///
+/// - Attrs:
+///     - output_types: If specified, defines the type of each tuple component in an
+///         element produced by the resulting iterator.
+///     - output_shapes: If specified, defines the shape of each tuple component in an
+///         element produced by the resulting iterator.
+///
+/// - Output resource_handle: A handle to an iterator resource.
+@inlinable @inline(__always)
+public static func iteratorFromStringHandle(
+    stringHandle: StringTensor,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("IteratorFromStringHandle", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(stringHandle)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func iteratorFromStringHandleV2(
+    stringHandle: StringTensor,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("IteratorFromStringHandleV2", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(stringHandle)
+    return op.execute(Int(1))
+}
+
+/// Gets the next output from the given iterator .
+@inlinable @inline(__always)
+public static func iteratorGetNext<OutputTypes: TensorGroup>(
+    iterator: ResourceHandle,
+    outputShapes: [TensorShape?]
+) -> OutputTypes {
+  let nOutputs = Int(OutputTypes._typeList.count)
+    let op = makeOp("IteratorGetNext", nOutputs)
+    op.updateAttribute("output_types", OutputTypes._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(iterator)
+    return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Gets the next output from the given iterator as an Optional variant.
+@inlinable @inline(__always)
+public static func iteratorGetNextAsOptional(
+    iterator: ResourceHandle,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("IteratorGetNextAsOptional", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(iterator)
+    return op.execute(Int(1))
+}
+
+/// Gets the next output from the given iterator.
+///
+/// This operation is a synchronous version IteratorGetNext. It should only be used
+/// in situations where the iterator does not block the calling thread, or where
+/// the calling thread is not a member of the thread pool used to execute parallel
+/// operations (e.g. in eager mode).
+@inlinable @inline(__always)
+public static func iteratorGetNextSync<OutputTypes: TensorGroup>(
+    iterator: ResourceHandle,
+    outputShapes: [TensorShape?]
+) -> OutputTypes {
+  let nOutputs = Int(OutputTypes._typeList.count)
+    let op = makeOp("IteratorGetNextSync", nOutputs)
+    op.updateAttribute("output_types", OutputTypes._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(iterator)
+    return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Converts the given `resource_handle` representing an iterator to a string.
+///
+/// - Parameter resource_handle: A handle to an iterator resource.
+///
+/// - Output string_handle: A string representation of the given handle.
+@inlinable @inline(__always)
+public static func iteratorToStringHandle(
+    resourceHandle: ResourceHandle
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("IteratorToStringHandle", nOutputs)
+    op.addInput(resourceHandle)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func iteratorV2(
+    sharedName: String,
+    container: String,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("IteratorV2", nOutputs)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("container", container)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    return op.execute(Int(1))
+}
+
+/// Returns the index of a data point that should be added to the seed set.
+///
+/// Entries in distances are assumed to be squared distances of candidate points to
+/// the already sampled centers in the seed set. The op constructs one Markov chain
+/// of the k-MC^2 algorithm and returns the index of one candidate point to be added
+/// as an additional cluster center.
+///
+/// - Parameters:
+///     - distances: Vector with squared distances to the closest previously sampled cluster center
+///         for each candidate point.
+///     - seed: Scalar. Seed for initializing the random number generator.
+///
+/// - Output index: Scalar with the index of the sampled point.
+@inlinable @inline(__always)
+public static func kMC2ChainInitialization(
+    distances: Tensor<Float>,
+    seed: Tensor<Int64>
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("KMC2ChainInitialization", nOutputs)
+    op.addInput(distances)
+    op.addInput(seed)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func kernelLabel(
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("KernelLabel", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func kernelLabelRequired(
+    _ input: Tensor<Int32>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("KernelLabelRequired", nOutputs)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Selects num_to_sample rows of input using the KMeans++ criterion.
+///
+/// Rows of points are assumed to be input points. One row is selected at random.
+/// Subsequent rows are sampled with probability proportional to the squared L2
+/// distance from the nearest row selected thus far till num_to_sample rows have
+/// been sampled.
+///
+/// - Parameters:
+///     - points: Matrix of shape (n, d). Rows are assumed to be input points.
+///     - num_to_sample: Scalar. The number of rows to sample. This value must not be larger than n.
+///     - seed: Scalar. Seed for initializing the random number generator.
+///     - num_retries_per_sample: Scalar. For each row that is sampled, this parameter
+///         specifies the number of additional points to draw from the current
+///         distribution before selecting the best. If a negative value is specified, a
+///         heuristic is used to sample O(log(num_to_sample)) additional points.
+///
+/// - Output samples: Matrix of shape (num_to_sample, d). The sampled rows.
+@inlinable @inline(__always)
+public static func kmeansPlusPlusInitialization(
+    points: Tensor<Float>,
+    numToSample: Tensor<Int64>,
+    seed: Tensor<Int64>,
+    numRetriesPerSample: Tensor<Int64>
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("KmeansPlusPlusInitialization", nOutputs)
+    op.addInput(points)
+    op.addInput(numToSample)
+    op.addInput(seed)
+    op.addInput(numRetriesPerSample)
+    return op.execute(Int(1))
+}
+
+/// L2 Loss.
+///
+/// Computes half the L2 norm of a tensor without the `sqrt`:
+///
+///     output = sum(t ** 2) / 2
+///
+/// - Parameter t: Typically 2-D, but may have any dimensions.
+///
+/// - Output output: 0-D.
+@inlinable @inline(__always)
+public static func l2Loss<T: FloatingPoint & TensorFlowScalar>(
+    t: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("L2Loss", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(t)
+    return op.execute(Int(1))
+}
+
+/// Local Response Normalization.
+///
+/// The 4-D `input` tensor is treated as a 3-D array of 1-D vectors (along the last
+/// dimension), and each vector is normalized independently.  Within a given vector,
+/// each component is divided by the weighted, squared sum of inputs within
+/// `depth_radius`.  In detail,
+///
+///     sqr_sum[a, b, c, d] =
+///         sum(input[a, b, c, d - depth_radius : d + depth_radius + 1] ** 2)
+///     output = input / (bias + alpha * sqr_sum) ** beta
+///
+/// For details, see [Krizhevsky et al., ImageNet classification with deep
+/// convolutional neural networks (NIPS 2012)](http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks).
+///
+/// - Parameter input: 4-D.
+///
+/// - Attrs:
+///     - depth_radius: 0-D.  Half-width of the 1-D normalization window.
+///     - bias: An offset (usually positive to avoid dividing by 0).
+///     - alpha: A scale factor, usually positive.
+///     - beta: An exponent.
+@inlinable @inline(__always)
+public static func lRN<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    depthRadius: Int64 = 5,
+    bias: Double = 1,
+    alpha: Double = 1,
+    beta: Double = 0.5
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("LRN", nOutputs)
+    op.updateAttribute("depth_radius", depthRadius)
+    op.updateAttribute("bias", bias)
+    op.updateAttribute("alpha", alpha)
+    op.updateAttribute("beta", beta)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Gradients for Local Response Normalization.
+///
+/// - Parameters:
+///     - input_grads: 4-D with shape `[batch, height, width, channels]`.
+///     - input_image: 4-D with shape `[batch, height, width, channels]`.
+///     - output_image: 4-D with shape `[batch, height, width, channels]`.
+///
+/// - Attrs:
+///     - depth_radius: A depth radius.
+///     - bias: An offset (usually > 0 to avoid dividing by 0).
+///     - alpha: A scale factor, usually positive.
+///     - beta: An exponent.
+///
+/// - Output output: The gradients for LRN.
+@inlinable @inline(__always)
+public static func lRNGrad<T: FloatingPoint & TensorFlowScalar>(
+    inputGrads: Tensor<T>,
+    inputImage: Tensor<T>,
+    outputImage: Tensor<T>,
+    depthRadius: Int64 = 5,
+    bias: Double = 1,
+    alpha: Double = 1,
+    beta: Double = 0.5
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("LRNGrad", nOutputs)
+    op.updateAttribute("depth_radius", depthRadius)
+    op.updateAttribute("bias", bias)
+    op.updateAttribute("alpha", alpha)
+    op.updateAttribute("beta", beta)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(inputGrads)
+    op.addInput(inputImage)
+    op.addInput(outputImage)
+    return op.execute(Int(1))
+}
+
+/// Computes the LSTM cell forward propagation for 1 time step.
+///
+/// This implementation uses 1 weight matrix and 1 bias vector, and there's an
+/// optional peephole connection.
+///
+/// This kernel op implements the following mathematical equations:
+///
+/// ```python
+/// xh = [x, h_prev]
+/// [i, f, ci, o] = xh * w + b
+/// f = f + forget_bias
+///
+/// if not use_peephole:
+///   wci = wcf = wco = 0
+///
+/// i = sigmoid(cs_prev * wci + i)
+/// f = sigmoid(cs_prev * wcf + f)
+/// ci = tanh(ci)
+///
+/// cs = ci .* i + cs_prev .* f
+/// cs = clip(cs, cell_clip)
+///
+/// o = sigmoid(cs * wco + o)
+/// co = tanh(cs)
+/// h = co .* o
+/// ```
+///
+/// - Parameters:
+///     - x: The input to the LSTM cell, shape (batch_size, num_inputs).
+///     - cs_prev: Value of the cell state at previous time step.
+///     - h_prev: Output of the previous cell at previous time step.
+///     - w: The weight matrix.
+///     - wci: The weight matrix for input gate peephole connection.
+///     - wcf: The weight matrix for forget gate peephole connection.
+///     - wco: The weight matrix for output gate peephole connection.
+///     - b: The bias vector.
+///
+/// - Attrs:
+///     - forget_bias: The forget gate bias.
+///     - cell_clip: Value to clip the 'cs' value to.
+///     - use_peephole: Whether to use peephole weights.
+///
+/// - Outputs:
+///     - i: The input gate.
+///     - cs: The cell state before the tanh.
+///     - f: The forget gate.
+///     - o: The output gate.
+///     - ci: The cell input.
+///     - co: The cell after the tanh.
+///     - h: The output h vector.
+@inlinable @inline(__always)
+public static func lSTMBlockCell<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    csPrev: Tensor<T>,
+    hPrev: Tensor<T>,
+    w: Tensor<T>,
+    wci: Tensor<T>,
+    wcf: Tensor<T>,
+    wco: Tensor<T>,
+    _ b: Tensor<T>,
+    forgetBias: Double = 1,
+    cellClip: Double = 3,
+    usePeephole: Bool = false
+) -> (i: Tensor<T>, cs: Tensor<T>, f: Tensor<T>, o: Tensor<T>, ci: Tensor<T>, co: Tensor<T>, h: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("LSTMBlockCell", nOutputs)
+    op.updateAttribute("forget_bias", forgetBias)
+    op.updateAttribute("cell_clip", cellClip)
+    op.updateAttribute("use_peephole", usePeephole)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(csPrev)
+    op.addInput(hPrev)
+    op.addInput(w)
+    op.addInput(wci)
+    op.addInput(wcf)
+    op.addInput(wco)
+    op.addInput(b)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Computes the LSTM cell backward propagation for 1 timestep.
+///
+/// This implementation is to be used in conjunction of LSTMBlockCell.
+///
+/// - Parameters:
+///     - x: The input to the LSTM cell, shape (batch_size, num_inputs).
+///     - cs_prev: The previous cell state.
+///     - h_prev: The previous h state.
+///     - w: The weight matrix.
+///     - wci: The weight matrix for input gate peephole connection.
+///     - wcf: The weight matrix for forget gate peephole connection.
+///     - wco: The weight matrix for output gate peephole connection.
+///     - b: The bias vector.
+///     - i: The input gate.
+///     - cs: The cell state before the tanh.
+///     - f: The forget gate.
+///     - o: The output gate.
+///     - ci: The cell input.
+///     - co: The cell after the tanh.
+///     - cs_grad: The current gradient of cs.
+///     - h_grad: The gradient of h vector.
+///
+/// - Attr use_peephole: Whether the cell uses peephole connections.
+///
+/// - Outputs:
+///     - cs_prev_grad: The gradient of cs to be back-propped.
+///     - dicfo: The derivative wrt to [i, cs, f, o].
+///     - wci_grad: The gradient for wci to be back-propped.
+///     - wcf_grad: The gradient for wcf to be back-propped.
+///     - wco_grad: The gradient for wco to be back-propped.
+@inlinable @inline(__always)
+public static func lSTMBlockCellGrad<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    csPrev: Tensor<T>,
+    hPrev: Tensor<T>,
+    w: Tensor<T>,
+    wci: Tensor<T>,
+    wcf: Tensor<T>,
+    wco: Tensor<T>,
+    _ b: Tensor<T>,
+    i: Tensor<T>,
+    cs: Tensor<T>,
+    f: Tensor<T>,
+    o: Tensor<T>,
+    ci: Tensor<T>,
+    co: Tensor<T>,
+    csGrad: Tensor<T>,
+    hGrad: Tensor<T>,
+    usePeephole: Bool
+) -> (csPrevGrad: Tensor<T>, dicfo: Tensor<T>, wciGrad: Tensor<T>, wcfGrad: Tensor<T>, wcoGrad: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("LSTMBlockCellGrad", nOutputs)
+    op.updateAttribute("use_peephole", usePeephole)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(csPrev)
+    op.addInput(hPrev)
+    op.addInput(w)
+    op.addInput(wci)
+    op.addInput(wcf)
+    op.addInput(wco)
+    op.addInput(b)
+    op.addInput(i)
+    op.addInput(cs)
+    op.addInput(f)
+    op.addInput(o)
+    op.addInput(ci)
+    op.addInput(co)
+    op.addInput(csGrad)
+    op.addInput(hGrad)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Computes rectified linear: `max(features, features * alpha)`.
+@inlinable @inline(__always)
+public static func leakyRelu<T: FloatingPoint & TensorFlowScalar>(
+    features: Tensor<T>,
+    alpha: Double = 0.2
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("LeakyRelu", nOutputs)
+    op.updateAttribute("alpha", alpha)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(features)
+    return op.execute(Int(1))
+}
+
+/// Computes rectified linear gradients for a LeakyRelu operation.
+///
+/// - Parameters:
+///     - gradients: The backpropagated gradients to the corresponding LeakyRelu operation.
+///     - features: The features passed as input to the corresponding LeakyRelu operation,
+///         OR the outputs of that operation (both work equivalently).
+///
+/// - Output backprops: `gradients * (features > 0) + alpha * gradients * (featurs <= 0)`.
+@inlinable @inline(__always)
+public static func leakyReluGrad<T: FloatingPoint & TensorFlowScalar>(
+    gradients: Tensor<T>,
+    features: Tensor<T>,
+    alpha: Double = 0.2
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("LeakyReluGrad", nOutputs)
+    op.updateAttribute("alpha", alpha)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(gradients)
+    op.addInput(features)
+    return op.execute(Int(1))
+}
+
+/// Generates labels for candidate sampling with a learned unigram distribution.
+///
+/// See explanations of candidate sampling and the data formats at
+/// go/candidate-sampling.
+///
+/// For each batch, this op picks a single set of sampled candidate labels.
+///
+/// The advantages of sampling candidates per-batch are simplicity and the
+/// possibility of efficient dense matrix multiplication. The disadvantage is that
+/// the sampled candidates must be chosen independently of the context and of the
+/// true labels.
+///
+/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
+///     IDs of the num_true target_classes in the corresponding original label.
+///
+/// - Attrs:
+///     - num_true: Number of true labels per context.
+///     - num_sampled: Number of candidates to randomly sample.
+///     - unique: If unique is true, we sample with rejection, so that all sampled
+///         candidates in a batch are unique. This requires some approximation to
+///         estimate the post-rejection sampling probabilities.
+///     - range_max: The sampler will sample integers from the interval [0, range_max).
+///     - seed: If either seed or seed2 are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///     - sampled_candidates: A vector of length num_sampled, in which each element is
+///         the ID of a sampled candidate.
+///     - true_expected_count: A batch_size * num_true matrix, representing
+///         the number of times each candidate is expected to occur in a batch
+///         of sampled candidates. If unique=true, then this is a probability.
+///     - sampled_expected_count: A vector of length num_sampled, for each sampled
+///         candidate representing the number of times the candidate is expected
+///         to occur in a batch of sampled candidates.  If unique=true, then this is a
+///         probability.
+@inlinable @inline(__always)
+public static func learnedUnigramCandidateSampler(
+    trueClasses: Tensor<Int64>,
+    numTrue: Int64,
+    numSampled: Int64,
+    unique: Bool,
+    rangeMax: Int64,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("LearnedUnigramCandidateSampler", nOutputs)
+    op.updateAttribute("num_true", numTrue)
+    op.updateAttribute("num_sampled", numSampled)
+    op.updateAttribute("unique", unique)
+    op.updateAttribute("range_max", rangeMax)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(trueClasses)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Elementwise computes the bitwise left-shift of `x` and `y`.
+///
+/// If `y` is negative, or greater than or equal to the width of `x` in bits the
+/// result is implementation defined.
+@inlinable @inline(__always)
+public static func leftShift<T: BinaryInteger & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("LeftShift", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x < y) element-wise.
+///
+/// *NOTE*: `Less` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func less<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("Less", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x <= y) element-wise.
+///
+/// *NOTE*: `LessEqual` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func lessEqual<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("LessEqual", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Computes the log of the absolute value of `Gamma(x)` element-wise.
+@inlinable @inline(__always)
+public static func lgamma<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Lgamma", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Generates values in an interval.
+///
+/// A sequence of `num` evenly-spaced values are generated beginning at `start`.
+/// If `num > 1`, the values in the sequence increase by `stop - start / num - 1`,
+/// so that the last one is exactly `stop`.
+///
+/// For example:
+///
+/// ```
+/// tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0  11.0  12.0]
+/// ```
+///
+/// - Parameters:
+///     - start: 0-D tensor. First entry in the range.
+///     - stop: 0-D tensor. Last entry in the range.
+///     - num: 0-D tensor. Number of values to generate.
+///
+/// - Output output: 1-D. The generated values.
+@inlinable @inline(__always)
+public static func linSpace<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    start: Tensor<T>,
+    stop: Tensor<T>,
+    num: Tensor<Tidx>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("LinSpace", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(start)
+    op.addInput(stop)
+    op.addInput(num)
+    return op.execute(Int(1))
+}
+
+/// Computes the difference between two lists of numbers or strings.
+///
+/// Given a list `x` and a list `y`, this operation returns a list `out` that
+/// represents all values that are in `x` but not in `y`. The returned list `out`
+/// is sorted in the same order that the numbers appear in `x` (duplicates are
+/// preserved). This operation also returns a list `idx` that represents the
+/// position of each `out` element in `x`. In other words:
+///
+/// `out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]`
+///
+/// For example, given this input:
+///
+/// ```
+/// x = [1, 2, 3, 4, 5, 6]
+/// y = [1, 3, 5]
+/// ```
+///
+/// This operation would return:
+///
+/// ```
+/// out ==> [2, 4, 6]
+/// idx ==> [1, 3, 5]
+/// ```
+///
+/// - Parameters:
+///     - x: 1-D. Values to keep.
+///     - y: 1-D. Values to remove.
+///
+/// - Outputs:
+///     - out: 1-D. Values present in `x` but not in `y`.
+///     - idx: 1-D. Positions of `x` values preserved in `out`.
+@inlinable @inline(__always)
+public static func listDiff<
+    T: TensorFlowScalar,
+    OutIdx: BinaryInteger & TensorFlowScalar
+>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> (out: Tensor<T>, idx: Tensor<OutIdx>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("ListDiff", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_idx", OutIdx.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func listInput<T: TensorFlowScalar>(
+    _ a: [Tensor<T>]
+) {
+  let nOutputs = 0
+    let op = makeOp("ListInput", nOutputs)
+    op.updateAttribute("N", a.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInputList(a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func listOutput<T: TensorGroup>(
+) -> T {
+  let nOutputs = Int(T._typeList.count)
+    let op = makeOp("ListOutput", nOutputs)
+    op.updateAttribute("T", T._typeList)
+    return op.execute(Int(T._typeList.count))
+}
+
+/// Loads a 2-D (matrix) `Tensor` with name `old_tensor_name` from the checkpoint
+///
+/// at `ckpt_path` and potentially reorders its rows and columns using the
+/// specified remappings.
+///
+/// Most users should use one of the wrapper initializers (such as
+/// `tf.contrib.framework.load_and_remap_matrix_initializer`) instead of this
+/// function directly.
+///
+/// The remappings are 1-D tensors with the following properties:
+///
+/// * `row_remapping` must have exactly `num_rows` entries. Row `i` of the output
+///   matrix will be initialized from the row corresponding to index
+///   `row_remapping[i]` in the old `Tensor` from the checkpoint.
+/// * `col_remapping` must have either 0 entries (indicating that no column
+///   reordering is needed) or `num_cols` entries. If specified, column `j` of the
+///   output matrix will be initialized from the column corresponding to index
+///   `col_remapping[j]` in the old `Tensor` from the checkpoint.
+/// * A value of -1 in either of the remappings signifies a "missing" entry. In that
+///   case, values from the `initializing_values` tensor will be used to fill that
+///   missing row or column. If `row_remapping` has `r` missing entries and
+///   `col_remapping` has `c` missing entries, then the following condition must be
+///   true:
+///
+/// `(r * num_cols) + (c * num_rows) - (r * c) == len(initializing_values)`
+///
+/// The remapping tensors can be generated using the GenerateVocabRemapping op.
+///
+/// As an example, with row_remapping = [1, 0, -1], col_remapping = [0, 2, -1],
+/// initializing_values = [0.5, -0.5, 0.25, -0.25, 42], and w(i, j) representing
+/// the value from row i, column j of the old tensor in the checkpoint, the output
+/// matrix will look like the following:
+///
+/// [[w(1, 0),  w(1, 2),  0.5],
+///  [w(0, 0),  w(0, 2), -0.5],
+///  [0.25,    -0.25,      42]]
+///
+/// - Parameters:
+///     - ckpt_path: Path to the TensorFlow checkpoint (version 2, `TensorBundle`) from
+///         which the old matrix `Tensor` will be loaded.
+///     - old_tensor_name: Name of the 2-D `Tensor` to load from checkpoint.
+///     - row_remapping: An int `Tensor` of row remappings (generally created by
+///         `generate_vocab_remapping`).  Even if no row remapping is needed, this must
+///         still be an index-valued Tensor (e.g. [0, 1, 2, ...]), or a shifted
+///         index-valued `Tensor` (e.g. [8, 9, 10, ...], for partitioned `Variables`).
+///     - col_remapping: An int `Tensor` of column remappings (generally created by
+///         `generate_vocab_remapping`).  May be a size-0 `Tensor` if only row remapping
+///         is to be done (e.g. column ordering is the same).
+///     - initializing_values: A float `Tensor` containing  values to fill in for cells
+///         in the output matrix that are not loaded from the checkpoint. Length must be
+///         exactly the same as the number of missing / new cells.
+///
+/// - Attrs:
+///     - num_rows: Number of rows (length of the 1st dimension) in the output matrix.
+///     - num_cols: Number of columns (length of the 2nd dimension) in the output matrix.
+///     - max_rows_in_memory: The maximum number of rows to load from the checkpoint at
+///         once. If less than or equal to 0, the entire matrix will be loaded into
+///         memory. Setting this arg trades increased disk reads for lower memory usage.
+///
+/// - Output output_matrix: Output matrix containing existing values loaded from the
+///     checkpoint, and with any missing values filled in from initializing_values.
+@inlinable @inline(__always)
+public static func loadAndRemapMatrix(
+    ckptPath: StringTensor,
+    oldTensorName: StringTensor,
+    rowRemapping: Tensor<Int64>,
+    colRemapping: Tensor<Int64>,
+    initializingValues: Tensor<Float>,
+    numRows: Int64,
+    numCols: Int64,
+    maxRowsInMemory: Int64 = -1
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("LoadAndRemapMatrix", nOutputs)
+    op.updateAttribute("num_rows", numRows)
+    op.updateAttribute("num_cols", numCols)
+    op.updateAttribute("max_rows_in_memory", maxRowsInMemory)
+    op.addInput(ckptPath)
+    op.addInput(oldTensorName)
+    op.addInput(rowRemapping)
+    op.addInput(colRemapping)
+    op.addInput(initializingValues)
+    return op.execute(Int(1))
+}
+
+/// Load ADAM embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the ADAM optimization algorithm.
+///     - momenta: Value of momenta used in the ADAM optimization algorithm.
+///     - velocities: Value of velocities used in the ADAM optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingADAMParameters(
+    parameters: Tensor<Float>,
+    momenta: Tensor<Float>,
+    velocities: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingADAMParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(momenta)
+    op.addInput(velocities)
+    op.execute()
+}
+
+/// Load ADAM embedding parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the ADAM optimization algorithm.
+///     - momenta: Value of momenta used in the ADAM optimization algorithm.
+///     - velocities: Value of velocities used in the ADAM optimization algorithm.
+///     - gradient_accumulators: Value of gradient_accumulators used in the ADAM optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingADAMParametersGradAccumDebug(
+    parameters: Tensor<Float>,
+    momenta: Tensor<Float>,
+    velocities: Tensor<Float>,
+    gradientAccumulators: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingADAMParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(momenta)
+    op.addInput(velocities)
+    op.addInput(gradientAccumulators)
+    op.execute()
+}
+
+/// Load Adadelta embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the Adadelta optimization algorithm.
+///     - accumulators: Value of accumulators used in the Adadelta optimization algorithm.
+///     - updates: Value of updates used in the Adadelta optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingAdadeltaParameters(
+    parameters: Tensor<Float>,
+    accumulators: Tensor<Float>,
+    updates: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingAdadeltaParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(accumulators)
+    op.addInput(updates)
+    op.execute()
+}
+
+/// Load Adadelta parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the Adadelta optimization algorithm.
+///     - accumulators: Value of accumulators used in the Adadelta optimization algorithm.
+///     - updates: Value of updates used in the Adadelta optimization algorithm.
+///     - gradient_accumulators: Value of gradient_accumulators used in the Adadelta optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingAdadeltaParametersGradAccumDebug(
+    parameters: Tensor<Float>,
+    accumulators: Tensor<Float>,
+    updates: Tensor<Float>,
+    gradientAccumulators: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingAdadeltaParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(accumulators)
+    op.addInput(updates)
+    op.addInput(gradientAccumulators)
+    op.execute()
+}
+
+/// Load Adagrad embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the Adagrad optimization algorithm.
+///     - accumulators: Value of accumulators used in the Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingAdagradParameters(
+    parameters: Tensor<Float>,
+    accumulators: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingAdagradParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(accumulators)
+    op.execute()
+}
+
+/// Load Adagrad embedding parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the Adagrad optimization algorithm.
+///     - accumulators: Value of accumulators used in the Adagrad optimization algorithm.
+///     - gradient_accumulators: Value of gradient_accumulators used in the Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingAdagradParametersGradAccumDebug(
+    parameters: Tensor<Float>,
+    accumulators: Tensor<Float>,
+    gradientAccumulators: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingAdagradParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(accumulators)
+    op.addInput(gradientAccumulators)
+    op.execute()
+}
+
+/// Load centered RMSProp embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the centered RMSProp optimization algorithm.
+///     - ms: Value of ms used in the centered RMSProp optimization algorithm.
+///     - mom: Value of mom used in the centered RMSProp optimization algorithm.
+///     - mg: Value of mg used in the centered RMSProp optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingCenteredRMSPropParameters(
+    parameters: Tensor<Float>,
+    ms: Tensor<Float>,
+    mom: Tensor<Float>,
+    mg: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingCenteredRMSPropParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(ms)
+    op.addInput(mom)
+    op.addInput(mg)
+    op.execute()
+}
+
+/// Load FTRL embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the FTRL optimization algorithm.
+///     - accumulators: Value of accumulators used in the FTRL optimization algorithm.
+///     - linears: Value of linears used in the FTRL optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingFTRLParameters(
+    parameters: Tensor<Float>,
+    accumulators: Tensor<Float>,
+    linears: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingFTRLParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(accumulators)
+    op.addInput(linears)
+    op.execute()
+}
+
+/// Load FTRL embedding parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the FTRL optimization algorithm.
+///     - accumulators: Value of accumulators used in the FTRL optimization algorithm.
+///     - linears: Value of linears used in the FTRL optimization algorithm.
+///     - gradient_accumulators: Value of gradient_accumulators used in the FTRL optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingFTRLParametersGradAccumDebug(
+    parameters: Tensor<Float>,
+    accumulators: Tensor<Float>,
+    linears: Tensor<Float>,
+    gradientAccumulators: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingFTRLParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(accumulators)
+    op.addInput(linears)
+    op.addInput(gradientAccumulators)
+    op.execute()
+}
+
+/// Load MDL Adagrad Light embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the MDL Adagrad Light optimization algorithm.
+///     - accumulators: Value of accumulators used in the MDL Adagrad Light optimization algorithm.
+///     - weights: Value of weights used in the MDL Adagrad Light optimization algorithm.
+///     - benefits: Value of benefits used in the MDL Adagrad Light optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingMDLAdagradLightParameters(
+    parameters: Tensor<Float>,
+    accumulators: Tensor<Float>,
+    weights: Tensor<Float>,
+    benefits: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingMDLAdagradLightParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(accumulators)
+    op.addInput(weights)
+    op.addInput(benefits)
+    op.execute()
+}
+
+/// Load Momentum embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the Momentum optimization algorithm.
+///     - momenta: Value of momenta used in the Momentum optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingMomentumParameters(
+    parameters: Tensor<Float>,
+    momenta: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingMomentumParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(momenta)
+    op.execute()
+}
+
+/// Load Momentum embedding parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the Momentum optimization algorithm.
+///     - momenta: Value of momenta used in the Momentum optimization algorithm.
+///     - gradient_accumulators: Value of gradient_accumulators used in the Momentum optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingMomentumParametersGradAccumDebug(
+    parameters: Tensor<Float>,
+    momenta: Tensor<Float>,
+    gradientAccumulators: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingMomentumParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(momenta)
+    op.addInput(gradientAccumulators)
+    op.execute()
+}
+
+/// Load proximal Adagrad embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the proximal Adagrad optimization algorithm.
+///     - accumulators: Value of accumulators used in the proximal Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingProximalAdagradParameters(
+    parameters: Tensor<Float>,
+    accumulators: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingProximalAdagradParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(accumulators)
+    op.execute()
+}
+
+/// Load proximal Adagrad embedding parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the proximal Adagrad optimization algorithm.
+///     - accumulators: Value of accumulators used in the proximal Adagrad optimization algorithm.
+///     - gradient_accumulators: Value of gradient_accumulators used in the proximal Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingProximalAdagradParametersGradAccumDebug(
+    parameters: Tensor<Float>,
+    accumulators: Tensor<Float>,
+    gradientAccumulators: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingProximalAdagradParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(accumulators)
+    op.addInput(gradientAccumulators)
+    op.execute()
+}
+
+/// Load RMSProp embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the RMSProp optimization algorithm.
+///     - ms: Value of ms used in the RMSProp optimization algorithm.
+///     - mom: Value of mom used in the RMSProp optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingRMSPropParameters(
+    parameters: Tensor<Float>,
+    ms: Tensor<Float>,
+    mom: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingRMSPropParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(ms)
+    op.addInput(mom)
+    op.execute()
+}
+
+/// Load RMSProp embedding parameters with debug support.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameters:
+///     - parameters: Value of parameters used in the RMSProp optimization algorithm.
+///     - ms: Value of ms used in the RMSProp optimization algorithm.
+///     - mom: Value of mom used in the RMSProp optimization algorithm.
+///     - gradient_accumulators: Value of gradient_accumulators used in the RMSProp optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingRMSPropParametersGradAccumDebug(
+    parameters: Tensor<Float>,
+    ms: Tensor<Float>,
+    mom: Tensor<Float>,
+    gradientAccumulators: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingRMSPropParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.addInput(ms)
+    op.addInput(mom)
+    op.addInput(gradientAccumulators)
+    op.execute()
+}
+
+/// Load SGD embedding parameters.
+///
+/// An op that loads optimization parameters into HBM for embedding. Must be
+/// preceded by a ConfigureTPUEmbeddingHost op that sets up the correct
+/// embedding table configuration. For example, this op is used to install
+/// parameters that are loaded from a checkpoint before a training loop is
+/// executed.
+///
+/// - Parameter parameters: Value of parameters used in the stochastic gradient descent optimization algorithm.
+@inlinable @inline(__always)
+public static func loadTPUEmbeddingStochasticGradientDescentParameters(
+    parameters: Tensor<Float>,
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("LoadTPUEmbeddingStochasticGradientDescentParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    op.addInput(parameters)
+    op.execute()
+}
+
+/// Computes natural logarithm of x element-wise.
+///
+/// I.e., \\(y = \log_e x\\).
+@inlinable @inline(__always)
+public static func log<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Log", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes natural logarithm of (1 + x) element-wise.
+///
+/// I.e., \\(y = \log_e (1 + x)\\).
+@inlinable @inline(__always)
+public static func log1p<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Log1p", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the sign and the log of the absolute value of the determinant of
+///
+/// one or more square matrices.
+///
+/// The input is a tensor of shape `[N, M, M]` whose inner-most 2 dimensions
+/// form square matrices. The outputs are two tensors containing the signs and
+/// absolute values of the log determinants for all N input submatrices
+/// `[..., :, :]` such that the determinant = sign*exp(log_abs_determinant).
+/// The log_abs_determinant is computed as det(P)*sum(log(diag(LU))) where LU
+/// is the LU decomposition of the input and P is the corresponding
+/// permutation matrix.
+///
+/// - Parameter input: Shape is `[N, M, M]`.
+///
+/// - Outputs:
+///     - sign: The signs of the log determinants of the inputs. Shape is `[N]`.
+///     - log_abs_determinant: The logs of the absolute values of the determinants
+///         of the N input matrices.  Shape is `[N]`.
+@inlinable @inline(__always)
+public static func logMatrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> (sign: Tensor<T>, logAbsDeterminant: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("LogMatrixDeterminant", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Computes log softmax activations.
+///
+/// For each batch `i` and class `j` we have
+///
+///     logsoftmax[i, j] = logits[i, j] - log(sum(exp(logits[i])))
+///
+/// - Parameter logits: 2-D with shape `[batch_size, num_classes]`.
+///
+/// - Output logsoftmax: Same shape as `logits`.
+@inlinable @inline(__always)
+public static func logSoftmax<T: FloatingPoint & TensorFlowScalar>(
+    logits: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("LogSoftmax", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(logits)
+    return op.execute(Int(1))
+}
+
+/// Generates labels for candidate sampling with a log-uniform distribution.
+///
+/// See explanations of candidate sampling and the data formats at
+/// go/candidate-sampling.
+///
+/// For each batch, this op picks a single set of sampled candidate labels.
+///
+/// The advantages of sampling candidates per-batch are simplicity and the
+/// possibility of efficient dense matrix multiplication. The disadvantage is that
+/// the sampled candidates must be chosen independently of the context and of the
+/// true labels.
+///
+/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
+///     IDs of the num_true target_classes in the corresponding original label.
+///
+/// - Attrs:
+///     - num_true: Number of true labels per context.
+///     - num_sampled: Number of candidates to randomly sample.
+///     - unique: If unique is true, we sample with rejection, so that all sampled
+///         candidates in a batch are unique. This requires some approximation to
+///         estimate the post-rejection sampling probabilities.
+///     - range_max: The sampler will sample integers from the interval [0, range_max).
+///     - seed: If either seed or seed2 are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///     - sampled_candidates: A vector of length num_sampled, in which each element is
+///         the ID of a sampled candidate.
+///     - true_expected_count: A batch_size * num_true matrix, representing
+///         the number of times each candidate is expected to occur in a batch
+///         of sampled candidates. If unique=true, then this is a probability.
+///     - sampled_expected_count: A vector of length num_sampled, for each sampled
+///         candidate representing the number of times the candidate is expected
+///         to occur in a batch of sampled candidates.  If unique=true, then this is a
+///         probability.
+@inlinable @inline(__always)
+public static func logUniformCandidateSampler(
+    trueClasses: Tensor<Int64>,
+    numTrue: Int64,
+    numSampled: Int64,
+    unique: Bool,
+    rangeMax: Int64,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("LogUniformCandidateSampler", nOutputs)
+    op.updateAttribute("num_true", numTrue)
+    op.updateAttribute("num_sampled", numSampled)
+    op.updateAttribute("unique", unique)
+    op.updateAttribute("range_max", rangeMax)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(trueClasses)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Returns the truth value of x AND y element-wise.
+///
+/// *NOTE*: `LogicalAnd` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func logicalAnd(
+    _ x: Tensor<Bool>,
+    _ y: Tensor<Bool>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("LogicalAnd", nOutputs)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns the truth value of NOT x element-wise.
+@inlinable @inline(__always)
+public static func logicalNot(
+    _ x: Tensor<Bool>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("LogicalNot", nOutputs)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns the truth value of x OR y element-wise.
+///
+/// *NOTE*: `LogicalOr` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func logicalOr(
+    _ x: Tensor<Bool>,
+    _ y: Tensor<Bool>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("LogicalOr", nOutputs)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Outputs all keys and values in the table.
+///
+/// - Parameter table_handle: Handle to the table.
+///
+/// - Outputs:
+///     - keys: Vector of all keys present in the table.
+///     - values: Tensor of all values in the table. Indexed in parallel with `keys`.
+@inlinable @inline(__always)
+public static func lookupTableExportV2<
+    Tkeys: TensorFlowScalar,
+    Tvalues: TensorFlowScalar
+>(
+    tableHandle: ResourceHandle
+) -> (keys: Tensor<Tkeys>, values: Tensor<Tvalues>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("LookupTableExportV2", nOutputs)
+    op.updateAttribute("Tkeys", Tkeys.tensorFlowDataType)
+    op.updateAttribute("Tvalues", Tvalues.tensorFlowDataType)
+    op.addInput(tableHandle)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Looks up keys in a table, outputs the corresponding values.
+///
+/// The tensor `keys` must of the same type as the keys of the table.
+/// The output `values` is of the type of the table values.
+///
+/// The scalar `default_value` is the value output for keys not present in the
+/// table. It must also be of the same type as the table values.
+///
+/// - Parameters:
+///     - table_handle: Handle to the table.
+///     - keys: Any shape.  Keys to look up.
+///
+/// - Output values: Same shape as `keys`.  Values found in the table, or `default_values`
+///     for missing keys.
+@inlinable @inline(__always)
+public static func lookupTableFindV2<
+    Tin: TensorFlowScalar,
+    Tout: TensorFlowScalar
+>(
+    tableHandle: ResourceHandle,
+    keys: Tensor<Tin>,
+    defaultValue: Tensor<Tout>
+) -> Tensor<Tout> {
+  let nOutputs = Int(1)
+    let op = makeOp("LookupTableFindV2", nOutputs)
+    op.updateAttribute("Tin", Tin.tensorFlowDataType)
+    op.updateAttribute("Tout", Tout.tensorFlowDataType)
+    op.addInput(tableHandle)
+    op.addInput(keys)
+    op.addInput(defaultValue)
+    return op.execute(Int(1))
+}
+
+/// Replaces the contents of the table with the specified keys and values.
+///
+/// The tensor `keys` must be of the same type as the keys of the table.
+/// The tensor `values` must be of the type of the table values.
+///
+/// - Parameters:
+///     - table_handle: Handle to the table.
+///     - keys: Any shape.  Keys to look up.
+///     - values: Values to associate with keys.
+@inlinable @inline(__always)
+public static func lookupTableImportV2<
+    Tin: TensorFlowScalar,
+    Tout: TensorFlowScalar
+>(
+    tableHandle: ResourceHandle,
+    keys: Tensor<Tin>,
+    _ values: Tensor<Tout>
+) {
+  let nOutputs = 0
+    let op = makeOp("LookupTableImportV2", nOutputs)
+    op.updateAttribute("Tin", Tin.tensorFlowDataType)
+    op.updateAttribute("Tout", Tout.tensorFlowDataType)
+    op.addInput(tableHandle)
+    op.addInput(keys)
+    op.addInput(values)
+    op.execute()
+}
+
+/// Updates the table to associates keys with values.
+///
+/// The tensor `keys` must be of the same type as the keys of the table.
+/// The tensor `values` must be of the type of the table values.
+///
+/// - Parameters:
+///     - table_handle: Handle to the table.
+///     - keys: Any shape.  Keys to look up.
+///     - values: Values to associate with keys.
+@inlinable @inline(__always)
+public static func lookupTableInsertV2<
+    Tin: TensorFlowScalar,
+    Tout: TensorFlowScalar
+>(
+    tableHandle: ResourceHandle,
+    keys: Tensor<Tin>,
+    _ values: Tensor<Tout>
+) {
+  let nOutputs = 0
+    let op = makeOp("LookupTableInsertV2", nOutputs)
+    op.updateAttribute("Tin", Tin.tensorFlowDataType)
+    op.updateAttribute("Tout", Tout.tensorFlowDataType)
+    op.addInput(tableHandle)
+    op.addInput(keys)
+    op.addInput(values)
+    op.execute()
+}
+
+/// Removes keys and its associated values from a table.
+///
+/// The tensor `keys` must of the same type as the keys of the table. Keys not
+/// already in the table are silently ignored.
+///
+/// - Parameters:
+///     - table_handle: Handle to the table.
+///     - keys: Any shape.  Keys of the elements to remove.
+@inlinable @inline(__always)
+public static func lookupTableRemoveV2<Tin: TensorFlowScalar>(
+    tableHandle: ResourceHandle,
+    keys: Tensor<Tin>
+) {
+  let nOutputs = 0
+    let op = makeOp("LookupTableRemoveV2", nOutputs)
+    op.updateAttribute("Tin", Tin.tensorFlowDataType)
+    op.addInput(tableHandle)
+    op.addInput(keys)
+    op.execute()
+}
+
+/// Computes the number of elements in the given table.
+///
+/// - Parameter table_handle: Handle to the table.
+///
+/// - Output size: Scalar that contains number of elements in the table.
+@inlinable @inline(__always)
+public static func lookupTableSizeV2(
+    tableHandle: ResourceHandle
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("LookupTableSizeV2", nOutputs)
+    op.addInput(tableHandle)
+    return op.execute(Int(1))
+}
+
+/// Forwards the input to the output.
+///
+/// This operator represents the loop termination condition used by the
+/// "pivot" switches of a loop.
+///
+/// - Parameter input: A boolean scalar, representing the branch predicate of the Switch op.
+///
+/// - Output output: The same tensor as `input`.
+@inlinable @inline(__always)
+public static func loopCond(
+    _ input: Tensor<Bool>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("LoopCond", nOutputs)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Applies lower_bound(sorted_search_values, values) along each row.
+///
+/// Each set of rows with the same index in (sorted_inputs, values) is treated
+/// independently.  The resulting row is the equivalent of calling
+/// `np.searchsorted(sorted_inputs, values, side='left')`.
+///
+/// The result is not a global index to the entire 
+/// `Tensor`, but rather just the index in the last dimension.
+///
+/// A 2-D example:
+///   sorted_sequence = [[0, 3, 9, 9, 10],
+///                      [1, 2, 3, 4, 5]]
+///   values = [[2, 4, 9],
+///             [0, 2, 6]]
+///
+///   result = LowerBound(sorted_sequence, values)
+///
+///   result == [[1, 2, 2],
+///              [0, 1, 5]]
+///
+/// - Parameters:
+///     - sorted_inputs: 2-D Tensor where each row is ordered.
+///     - values: 2-D Tensor with the same numbers of rows as `sorted_search_values`. Contains
+///         the values that will be searched for in `sorted_search_values`.
+///
+/// - Output output: A `Tensor` with the same shape as `values`.  It contains the first scalar index
+///     into the last dimension where values can be inserted without changing the
+///     ordered property.
+@inlinable @inline(__always)
+public static func lowerBound<
+    T: TensorFlowScalar,
+    OutType: BinaryInteger & TensorFlowScalar
+>(
+    sortedInputs: Tensor<T>,
+    _ values: Tensor<T>
+) -> Tensor<OutType> {
+  let nOutputs = Int(1)
+    let op = makeOp("LowerBound", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(sortedInputs)
+    op.addInput(values)
+    return op.execute(Int(1))
+}
+
+/// Computes the LU decomposition of one or more square matrices.
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices.
+///
+/// The input has to be invertible.
+///
+/// The output consists of two tensors LU and P containing the LU decomposition
+/// of all input submatrices `[..., :, :]`. LU encodes the lower triangular and
+/// upper triangular factors.
+///
+/// For each input submatrix of shape `[M, M]`, L is a lower triangular matrix of
+/// shape `[M, M]` with unit diagonal whose entries correspond to the strictly lower
+/// triangular part of LU. U is a upper triangular matrix of shape `[M, M]` whose
+/// entries correspond to the upper triangular part, including the diagonal, of LU.
+///
+/// P represents a permutation matrix encoded as a list of indices each between `0`
+/// and `M-1`, inclusive. If P_mat denotes the permutation matrix corresponding to
+/// P, then the L, U and P satisfies P_mat * input = L * U.
+///
+/// - Parameter input: A tensor of shape `[..., M, M]` whose inner-most 2 dimensions form matrices of
+///     size `[M, M]`.
+///
+/// - Outputs:
+///     - lu: A tensor of shape `[..., M, M]` whose strictly lower triangular part denotes the
+///         lower triangular factor `L` with unit diagonal, and whose upper triangular part
+///         denotes the upper triangular factor `U`.
+///     - p: Permutation of the rows encoded as a list of indices in `0..M-1`. Shape is
+///         `[..., M]`.
+///         @compatibility(scipy)
+///         Similar to `scipy.linalg.lu`, except the triangular factors `L` and `U` are
+///         packed into a single tensor, the permutation is applied to `input` instead of
+///         the right hand side and the permutation `P` is returned as a list of indices
+///         instead of a permutation matrix.
+///         @end_compatibility
+@inlinable @inline(__always)
+public static func lu<
+    T: FloatingPoint & TensorFlowScalar,
+    OutputIdxType: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>
+) -> (lu: Tensor<T>, p: Tensor<OutputIdxType>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("Lu", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("output_idx_type", OutputIdxType.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Makes a new iterator from the given `dataset` and stores it in `iterator`.
+///
+/// This operation may be executed multiple times. Each execution will reset the
+/// iterator in `iterator` to the first element of `dataset`.
+@inlinable @inline(__always)
+public static func makeIterator(
+    dataset: VariantHandle,
+    iterator: ResourceHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("MakeIterator", nOutputs)
+    op.addInput(dataset)
+    op.addInput(iterator)
+    op.execute()
+}
+
+/// Op removes all elements in the underlying container.
+@inlinable @inline(__always)
+public static func mapClear(
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    dtypes: [TensorDataType],
+    container: String,
+    sharedName: String
+) {
+  let nOutputs = 0
+    let op = makeOp("MapClear", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", dtypes)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.execute()
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+@inlinable @inline(__always)
+public static func mapDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    otherArguments: Targuments,
+    f: (FIn) -> FOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?],
+    useInterOpParallelism: Bool = true,
+    preserveCardinality: Bool = false
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("MapDataset", nOutputs)
+    op.updateAttribute("f", f)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("use_inter_op_parallelism", useInterOpParallelism)
+    op.updateAttribute("preserve_cardinality", preserveCardinality)
+    op.addInput(inputDataset)
+    op.addInputList(otherArguments)
+    return op.execute(Int(1))
+}
+
+///   Maps a function on the list of tensors unpacked from arguments on dimension 0.
+///   The function given by `f` is assumed to be stateless, and is executed
+///   concurrently on all the slices; up to batch_size (i.e. the size of the 0th
+///   dimension of each argument) functions will be scheduled at once.
+///
+///   The `max_intra_op_parallelism` attr, which defaults to 1, can be used to
+///   limit the intra op parallelism. To limit inter-op parallelism, a user can
+///   set a private threadpool on the dataset using `tf.data.Options`'s
+///   `ThreadingOptions`.
+///
+///   Note that this op is not exposed to users directly, but is invoked in tf.data
+///   rewrites.
+///
+/// - Parameters:
+///     - arguments:     A list of tensors whose types are `Targuments`, corresponding to the inputs
+///             the function should be mapped over.
+///     - captured_inputs:     A list of tensors whose types are `Tcaptured`, corresponding to the captured
+///             inputs of the defun.
+///
+/// - Attrs:
+///     - Targuments: A list of types.
+///     - Tcaptured: A list of types.
+///     - output_types: A list of types.
+///     - output_shapes: A list of shapes.
+///
+/// - Output output:     A list of output tensors whose types are `output_types` and whose dimensions
+///         0 are the same as the dimensions 0 of the tensors in `arguments`, and whose
+///         remaining dimensions correspond to those in `output_shapes`.
+@inlinable @inline(__always)
+public static func mapDefun<
+    Targuments: TensorArrayProtocol,
+    Tcaptured: TensorArrayProtocol,
+    OutputTypes: TensorGroup,
+    FIn: TensorGroup,
+    FOut: TensorGroup
+>(
+    arguments: Targuments,
+    capturedInputs: Tcaptured,
+    outputShapes: [TensorShape?],
+    f: (FIn) -> FOut,
+    maxIntraOpParallelism: Int64 = 1
+) -> OutputTypes {
+  let nOutputs = Int(OutputTypes._typeList.count)
+    let op = makeOp("MapDefun", nOutputs)
+    op.updateAttribute("Targuments", arguments._typeList)
+    op.updateAttribute("Tcaptured", capturedInputs._typeList)
+    op.updateAttribute("output_types", OutputTypes._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("f", f)
+    op.updateAttribute("max_intra_op_parallelism", maxIntraOpParallelism)
+    op.addInputList(arguments)
+    op.addInputList(capturedInputs)
+    return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Op returns the number of incomplete elements in the underlying container.
+@inlinable @inline(__always)
+public static func mapIncompleteSize(
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    dtypes: [TensorDataType],
+    container: String,
+    sharedName: String
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("MapIncompleteSize", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", dtypes)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Op peeks at the values at the specified key.  If the
+///
+/// underlying container does not contain this key
+/// this op will block until it does.
+@inlinable @inline(__always)
+public static func mapPeek<Dtypes: TensorGroup>(
+    key: Tensor<Int64>,
+    indices: Tensor<Int32>,
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    container: String,
+    sharedName: String
+) -> Dtypes {
+  let nOutputs = Int(Dtypes._typeList.count)
+    let op = makeOp("MapPeek", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", Dtypes._typeList)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(key)
+    op.addInput(indices)
+    return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// Op returns the number of elements in the underlying container.
+@inlinable @inline(__always)
+public static func mapSize(
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    dtypes: [TensorDataType],
+    container: String,
+    sharedName: String
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("MapSize", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", dtypes)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Stage (key, values) in the underlying container which behaves like a hashtable.
+///
+/// - Parameters:
+///     - key: int64
+///     - values: a list of tensors
+///         dtypes A list of data types that inserted values should adhere to.
+///
+/// - Attrs:
+///     - capacity: Maximum number of elements in the Staging Area. If > 0, inserts
+///         on the container will block when the capacity is reached.
+///     - container: If non-empty, this queue is placed in the given container. Otherwise,
+///         a default container is used.
+///     - shared_name: It is necessary to match this name to the matching Unstage Op.
+@inlinable @inline(__always)
+public static func mapStage<FakeDtypes: TensorArrayProtocol>(
+    key: Tensor<Int64>,
+    indices: Tensor<Int32>,
+    _ values: FakeDtypes,
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    dtypes: [TensorDataType],
+    container: String,
+    sharedName: String
+) {
+  let nOutputs = 0
+    let op = makeOp("MapStage", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", dtypes)
+    op.updateAttribute("fake_dtypes", values._typeList)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(key)
+    op.addInput(indices)
+    op.addInputList(values)
+    op.execute()
+}
+
+/// Op removes and returns the values associated with the key
+///
+/// from the underlying container.   If the underlying container
+/// does not contain this key, the op will block until it does.
+@inlinable @inline(__always)
+public static func mapUnstage<Dtypes: TensorGroup>(
+    key: Tensor<Int64>,
+    indices: Tensor<Int32>,
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    container: String,
+    sharedName: String
+) -> Dtypes {
+  let nOutputs = Int(Dtypes._typeList.count)
+    let op = makeOp("MapUnstage", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", Dtypes._typeList)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(key)
+    op.addInput(indices)
+    return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// Op removes and returns a random (key, value)
+///
+/// from the underlying container.   If the underlying container
+/// does not contain elements, the op will block until it does.
+@inlinable @inline(__always)
+public static func mapUnstageNoKey<Dtypes: TensorGroup>(
+    indices: Tensor<Int32>,
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    container: String,
+    sharedName: String
+) -> (key: Tensor<Int64>, values: Dtypes) {
+  let nOutputs = Int(1) + Int(Dtypes._typeList.count)
+    let op = makeOp("MapUnstageNoKey", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", Dtypes._typeList)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(indices)
+    return op.execute(Int(1), Int(Dtypes._typeList.count))
+}
+
+/// Multiply the matrix "a" by the matrix "b".
+///
+/// The inputs must be two-dimensional matrices and the inner dimension of
+/// "a" (after being transposed if transpose_a is true) must match the
+/// outer dimension of "b" (after being transposed if transposed_b is
+/// true).
+///
+/// *Note*: The default kernel implementation for MatMul on GPUs uses
+/// cublas.
+///
+/// - Attrs:
+///     - transpose_a: If true, "a" is transposed before multiplication.
+///     - transpose_b: If true, "b" is transposed before multiplication.
+@inlinable @inline(__always)
+public static func matMul<T: Numeric & TensorFlowScalar>(
+    _ a: Tensor<T>,
+    _ b: Tensor<T>,
+    transposeA: Bool = false,
+    transposeB: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatMul", nOutputs)
+    op.updateAttribute("transpose_a", transposeA)
+    op.updateAttribute("transpose_b", transposeB)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    op.addInput(b)
+    return op.execute(Int(1))
+}
+
+/// Returns the set of files matching one or more glob patterns.
+///
+/// Note that this routine only supports wildcard characters in the
+/// basename portion of the pattern, not in the directory portion.
+/// Note also that the order of filenames returned can be non-deterministic.
+///
+/// - Parameter pattern: Shell wildcard pattern(s). Scalar or vector of type string.
+///
+/// - Output filenames: A vector of matching filenames.
+@inlinable @inline(__always)
+public static func matchingFiles(
+    pattern: StringTensor
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("MatchingFiles", nOutputs)
+    op.addInput(pattern)
+    return op.execute(Int(1))
+}
+
+/// Copy a tensor setting everything outside a central band in each innermost matrix
+///
+/// to zero.
+///
+/// The `band` part is computed as follows:
+/// Assume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a
+/// tensor with the same shape where
+///
+/// `band[i, j, k, ..., m, n] = in_band(m, n) * input[i, j, k, ..., m, n]`.
+///
+/// The indicator function
+///
+/// `in_band(m, n) = (num_lower < 0 || (m-n) <= num_lower)) &&
+///                  (num_upper < 0 || (n-m) <= num_upper)`.
+///
+/// For example:
+///
+/// ```
+/// # if 'input' is [[ 0,  1,  2, 3]
+///                  [-1,  0,  1, 2]
+///                  [-2, -1,  0, 1]
+///                  [-3, -2, -1, 0]],
+///
+/// tf.matrix_band_part(input, 1, -1) ==> [[ 0,  1,  2, 3]
+///                                        [-1,  0,  1, 2]
+///                                        [ 0, -1,  0, 1]
+///                                        [ 0,  0, -1, 0]],
+///
+/// tf.matrix_band_part(input, 2, 1) ==> [[ 0,  1,  0, 0]
+///                                       [-1,  0,  1, 0]
+///                                       [-2, -1,  0, 1]
+///                                       [ 0, -2, -1, 0]]
+/// ```
+///
+/// Useful special cases:
+///
+/// ```
+///  tf.matrix_band_part(input, 0, -1) ==> Upper triangular part.
+///  tf.matrix_band_part(input, -1, 0) ==> Lower triangular part.
+///  tf.matrix_band_part(input, 0, 0) ==> Diagonal.
+/// ```
+///
+/// - Parameters:
+///     - input: Rank `k` tensor.
+///     - num_lower: 0-D tensor. Number of subdiagonals to keep. If negative, keep entire
+///         lower triangle.
+///     - num_upper: 0-D tensor. Number of superdiagonals to keep. If negative, keep
+///         entire upper triangle.
+///
+/// - Output band: Rank `k` tensor of the same shape as input. The extracted banded tensor.
+@inlinable @inline(__always)
+public static func matrixBandPart<
+    T: TensorFlowScalar,
+    Tindex: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    numLower: Tensor<Tindex>,
+    numUpper: Tensor<Tindex>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatrixBandPart", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindex", Tindex.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(numLower)
+    op.addInput(numUpper)
+    return op.execute(Int(1))
+}
+
+/// Computes the determinant of one or more square matrices.
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices. The output is a tensor containing the determinants
+/// for all input submatrices `[..., :, :]`.
+///
+/// - Parameter input: Shape is `[..., M, M]`.
+///
+/// - Output output: Shape is `[...]`.
+@inlinable @inline(__always)
+public static func matrixDeterminant<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatrixDeterminant", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Returns a batched diagonal tensor with a given batched diagonal values.
+///
+/// Given a `diagonal`, this operation returns a tensor with the `diagonal` and
+/// everything else padded with zeros. The diagonal is computed as follows:
+///
+/// Assume `diagonal` has `k` dimensions `[I, J, K, ..., N]`, then the output is a
+/// tensor of rank `k+1` with dimensions [I, J, K, ..., N, N]` where:
+///
+/// `output[i, j, k, ..., m, n] = 1{m=n} * diagonal[i, j, k, ..., n]`.
+///
+/// For example:
+///
+/// ```
+/// # 'diagonal' is [[1, 2, 3, 4], [5, 6, 7, 8]]
+///
+/// and diagonal.shape = (2, 4)
+///
+/// tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0]
+///                                      [0, 2, 0, 0]
+///                                      [0, 0, 3, 0]
+///                                      [0, 0, 0, 4]],
+///                                     [[5, 0, 0, 0]
+///                                      [0, 6, 0, 0]
+///                                      [0, 0, 7, 0]
+///                                      [0, 0, 0, 8]]]
+///
+/// which has shape (2, 4, 4)
+/// ```
+///
+/// - Parameter diagonal: Rank `k`, where `k >= 1`.
+///
+/// - Output output: Rank `k+1`, with `output.shape = diagonal.shape + [diagonal.shape[-1]]`.
+@inlinable @inline(__always)
+public static func matrixDiag<T: TensorFlowScalar>(
+    diagonal: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatrixDiag", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(diagonal)
+    return op.execute(Int(1))
+}
+
+/// Returns the batched diagonal part of a batched tensor.
+///
+/// This operation returns a tensor with the `diagonal` part
+/// of the batched `input`. The `diagonal` part is computed as follows:
+///
+/// Assume `input` has `k` dimensions `[I, J, K, ..., M, N]`, then the output is a
+/// tensor of rank `k - 1` with dimensions `[I, J, K, ..., min(M, N)]` where:
+///
+/// `diagonal[i, j, k, ..., n] = input[i, j, k, ..., n, n]`.
+///
+/// The input must be at least a matrix.
+///
+/// For example:
+///
+/// ```
+/// # 'input' is [[[1, 0, 0, 0]
+///                [0, 2, 0, 0]
+///                [0, 0, 3, 0]
+///                [0, 0, 0, 4]],
+///               [[5, 0, 0, 0]
+///                [0, 6, 0, 0]
+///                [0, 0, 7, 0]
+///                [0, 0, 0, 8]]]
+///
+/// and input.shape = (2, 4, 4)
+///
+/// tf.matrix_diag_part(input) ==> [[1, 2, 3, 4], [5, 6, 7, 8]]
+///
+/// which has shape (2, 4)
+/// ```
+///
+/// - Parameter input: Rank `k` tensor where `k >= 2`.
+///
+/// - Output diagonal: The extracted diagonal(s) having shape
+///     `diagonal.shape = input.shape[:-2] + [min(input.shape[-2:])]`.
+@inlinable @inline(__always)
+public static func matrixDiagPart<T: TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatrixDiagPart", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Deprecated, use python implementation tf.linalg.matrix_exponential.
+@inlinable @inline(__always)
+public static func matrixExponential<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatrixExponential", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Computes the inverse of one or more square invertible matrices or their
+///
+/// adjoints (conjugate transposes).
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices. The output is a tensor of the same shape as the input
+/// containing the inverse for all input submatrices `[..., :, :]`.
+///
+/// The op uses LU decomposition with partial pivoting to compute the inverses.
+///
+/// If a matrix is not invertible there is no guarantee what the op does. It
+/// may detect the condition and raise an exception or it may simply return a
+/// garbage result.
+///
+/// - Parameter input: Shape is `[..., M, M]`.
+///
+/// - Output output: Shape is `[..., M, M]`.
+///
+///     @compatibility(numpy)
+///     Equivalent to np.linalg.inv
+///     @end_compatibility
+@inlinable @inline(__always)
+public static func matrixInverse<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    adjoint: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatrixInverse", nOutputs)
+    op.updateAttribute("adjoint", adjoint)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Computes the matrix logarithm of one or more square matrices:
+///
+///
+/// \\(log(exp(A)) = A\\)
+///
+/// This op is only defined for complex matrices. If A is positive-definite and
+/// real, then casting to a complex matrix, taking the logarithm and casting back
+/// to a real matrix will give the correct result.
+///
+/// This function computes the matrix logarithm using the Schur-Parlett algorithm.
+/// Details of the algorithm can be found in Section 11.6.2 of:
+/// Nicholas J. Higham, Functions of Matrices: Theory and Computation, SIAM 2008.
+/// ISBN 978-0-898716-46-7.
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices. The output is a tensor of the same shape as the input
+/// containing the exponential for all input submatrices `[..., :, :]`.
+///
+/// - Parameter input: Shape is `[..., M, M]`.
+///
+/// - Output output: Shape is `[..., M, M]`.
+///
+///     @compatibility(scipy)
+///     Equivalent to scipy.linalg.logm
+///     @end_compatibility
+@inlinable @inline(__always)
+public static func matrixLogarithm<T: TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatrixLogarithm", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(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`.
+///
+/// - Parameters:
+///     - input: Rank `k+1`, where `k >= 1`.
+///     - diagonal: Rank `k`, where `k >= 1`.
+///
+/// - Output output: Rank `k+1`, with `output.shape = input.shape`.
+@inlinable @inline(__always)
+public static func matrixSetDiag<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    diagonal: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatrixSetDiag", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(diagonal)
+    return op.execute(Int(1))
+}
+
+/// Solves systems of linear equations.
+///
+/// `Matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices. `Rhs` is a tensor of shape `[..., M, K]`. The `output` is
+/// a tensor shape `[..., M, K]`.  If `adjoint` is `False` then each output matrix
+/// satisfies `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
+/// If `adjoint` is `True` then each output matrix satisfies
+/// `adjoint(matrix[..., :, :]) * output[..., :, :] = rhs[..., :, :]`.
+///
+/// - Parameters:
+///     - matrix: Shape is `[..., M, M]`.
+///     - rhs: Shape is `[..., M, K]`.
+///
+/// - Attr adjoint: Boolean indicating whether to solve with `matrix` or its (block-wise)
+///     adjoint.
+///
+/// - Output output: Shape is `[..., M, K]`.
+@inlinable @inline(__always)
+public static func matrixSolve<T: FloatingPoint & TensorFlowScalar>(
+    matrix: Tensor<T>,
+    rhs: Tensor<T>,
+    adjoint: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatrixSolve", nOutputs)
+    op.updateAttribute("adjoint", adjoint)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(matrix)
+    op.addInput(rhs)
+    return op.execute(Int(1))
+}
+
+/// Solves one or more linear least-squares problems.
+///
+/// `matrix` is a tensor of shape `[..., M, N]` whose inner-most 2 dimensions
+/// form real or complex matrices of size `[M, N]`. `Rhs` is a tensor of the same
+/// type as `matrix` and shape `[..., M, K]`.
+/// The output is a tensor shape `[..., N, K]` where each output matrix solves
+/// each of the equations
+/// `matrix[..., :, :]` * `output[..., :, :]` = `rhs[..., :, :]`
+/// in the least squares sense.
+///
+/// We use the following notation for (complex) matrix and right-hand sides
+/// in the batch:
+///
+/// `matrix`=\\(A \in \mathbb{C}^{m \times n}\\),
+/// `rhs`=\\(B  \in \mathbb{C}^{m \times k}\\),
+/// `output`=\\(X  \in \mathbb{C}^{n \times k}\\),
+/// `l2_regularizer`=\\(\lambda \in \mathbb{R}\\).
+///
+/// If `fast` is `True`, then the solution is computed by solving the normal
+/// equations using Cholesky decomposition. Specifically, if \\(m \ge n\\) then
+/// \\(X = (A^H A + \lambda I)^{-1} A^H B\\), which solves the least-squares
+/// problem \\(X = \mathrm{argmin}_{Z \in \Re^{n \times k} } ||A Z - B||_F^2 + \lambda ||Z||_F^2\\). 
+/// If \\(m \lt n\\) then `output` is computed as
+/// \\(X = A^H (A A^H + \lambda I)^{-1} B\\), which (for \\(\lambda = 0\\)) is the
+/// minimum-norm solution to the under-determined linear system, i.e.
+/// \\(X = \mathrm{argmin}_{Z \in \mathbb{C}^{n \times k} } ||Z||_F^2 \\),
+/// subject to \\(A Z = B\\). Notice that the fast path is only numerically stable
+/// when \\(A\\) is numerically full rank and has a condition number
+/// \\(\mathrm{cond}(A) \lt \frac{1}{\sqrt{\epsilon_{mach} } }\\) or \\(\lambda\\) is
+/// sufficiently large.
+///
+/// If `fast` is `False` an algorithm based on the numerically robust complete
+/// orthogonal decomposition is used. This computes the minimum-norm
+/// least-squares solution, even when \\(A\\) is rank deficient. This path is
+/// typically 6-7 times slower than the fast path. If `fast` is `False` then
+/// `l2_regularizer` is ignored.
+///
+/// - Parameters:
+///     - matrix: Shape is `[..., M, N]`.
+///     - rhs: Shape is `[..., M, K]`.
+///     - l2_regularizer: Scalar tensor.
+///
+///         @compatibility(numpy)
+///         Equivalent to np.linalg.lstsq
+///         @end_compatibility
+///
+/// - Output output: Shape is `[..., N, K]`.
+@inlinable @inline(__always)
+public static func matrixSolveLs<T: FloatingPoint & TensorFlowScalar>(
+    matrix: Tensor<T>,
+    rhs: Tensor<T>,
+    l2Regularizer: Tensor<Double>,
+    fast: Bool = true
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatrixSolveLs", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("fast", fast)
+    op.addInput(matrix)
+    op.addInput(rhs)
+    op.addInput(l2Regularizer)
+    return op.execute(Int(1))
+}
+
+/// Computes the matrix square root of one or more square matrices:
+///
+/// matmul(sqrtm(A), sqrtm(A)) = A
+///
+/// The input matrix should be invertible. If the input matrix is real, it should
+/// have no eigenvalues which are real and negative (pairs of complex conjugate
+/// eigenvalues are allowed).
+///
+/// The matrix square root is computed by first reducing the matrix to 
+/// quasi-triangular form with the real Schur decomposition. The square root 
+/// of the quasi-triangular matrix is then computed directly. Details of 
+/// the algorithm can be found in: Nicholas J. Higham, "Computing real 
+/// square roots of a real matrix", Linear Algebra Appl., 1987.
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices. The output is a tensor of the same shape as the input
+/// containing the matrix square root for all input submatrices `[..., :, :]`.
+///
+/// - Parameter input: Shape is `[..., M, M]`.
+///
+/// - Output output: Shape is `[..., M, M]`.
+///
+///     @compatibility(scipy)
+///     Equivalent to scipy.linalg.sqrtm
+///     @end_compatibility
+@inlinable @inline(__always)
+public static func matrixSquareRoot<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatrixSquareRoot", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Solves systems of linear equations with upper or lower triangular matrices by
+///
+/// backsubstitution.
+///
+/// `matrix` is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions form
+/// square matrices. If `lower` is `True` then the strictly upper triangular part
+/// of each inner-most matrix is assumed to be zero and not accessed.
+/// If `lower` is False then the strictly lower triangular part of each inner-most
+/// matrix is assumed to be zero and not accessed.
+/// `rhs` is a tensor of shape `[..., M, K]`.
+///
+/// The output is a tensor of shape `[..., M, K]`. If `adjoint` is
+/// `True` then the innermost matrices in `output` satisfy matrix equations
+/// `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`.
+/// If `adjoint` is `False` then the strictly then the  innermost matrices in
+/// `output` satisfy matrix equations
+/// `adjoint(matrix[..., i, k]) * output[..., k, j] = rhs[..., i, j]`.
+///
+/// - Parameters:
+///     - matrix: Shape is `[..., M, M]`.
+///     - rhs: Shape is `[..., M, K]`.
+///
+/// - Attrs:
+///     - lower: Boolean indicating whether the innermost matrices in `matrix` are
+///         lower or upper triangular.
+///     - adjoint: Boolean indicating whether to solve with `matrix` or its (block-wise)
+///                  adjoint.
+///
+///         @compatibility(numpy)
+///         Equivalent to scipy.linalg.solve_triangular
+///         @end_compatibility
+///
+/// - Output output: Shape is `[..., M, K]`.
+@inlinable @inline(__always)
+public static func matrixTriangularSolve<T: FloatingPoint & TensorFlowScalar>(
+    matrix: Tensor<T>,
+    rhs: Tensor<T>,
+    lower: Bool = true,
+    adjoint: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MatrixTriangularSolve", nOutputs)
+    op.updateAttribute("lower", lower)
+    op.updateAttribute("adjoint", adjoint)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(matrix)
+    op.addInput(rhs)
+    return op.execute(Int(1))
+}
+
+/// Computes the maximum of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///     - input: The tensor to reduce.
+///     - reduction_indices: The dimensions to reduce. Must be in the range
+///         `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func max<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    reductionIndices: Tensor<Tidx>,
+    keepDims: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Max", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(reductionIndices)
+    return op.execute(Int(1))
+}
+
+/// Performs max pooling on the input.
+///
+/// - Parameter input: 4-D input to pool over.
+///
+/// - Attrs:
+///     - ksize: The size of the window for each dimension of the input tensor.
+///     - strides: The stride of the sliding window for each dimension of the
+///         input tensor.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, in_channels, in_height, in_width].
+///
+/// - Output output: The max pooled output tensor.
+@inlinable @inline(__always)
+public static func maxPool<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat4 = .nhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MaxPool", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Performs 3D max pooling on the input.
+///
+/// - Parameter input: Shape `[batch, depth, rows, cols, channels]` tensor to pool over.
+///
+/// - Attrs:
+///     - ksize: 1-D tensor of length 5. The size of the window for each dimension of
+///         the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+///     - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///         dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: The data format of the input and output data. With the
+///         default format "NDHWC", the data is stored in the order of:
+///             [batch, in_depth, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCDHW", the data storage order is:
+///             [batch, in_channels, in_depth, in_height, in_width].
+///
+/// - Output output: The max pooled output tensor.
+@inlinable @inline(__always)
+public static func maxPool3D<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat1 = .ndhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MaxPool3D", nOutputs)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Computes gradients of max pooling function.
+///
+/// - Parameters:
+///     - orig_input: The original input tensor.
+///     - orig_output: The original output tensor.
+///     - grad: Output backprop of shape `[batch, depth, rows, cols, channels]`.
+///
+/// - Attrs:
+///     - ksize: 1-D tensor of length 5. The size of the window for each dimension of
+///         the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+///     - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///         dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: The data format of the input and output data. With the
+///         default format "NDHWC", the data is stored in the order of:
+///             [batch, in_depth, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCDHW", the data storage order is:
+///             [batch, in_channels, in_depth, in_height, in_width].
+@inlinable @inline(__always)
+public static func maxPool3DGrad<
+    T: FloatingPoint & TensorFlowScalar,
+    Tinput: FloatingPoint & TensorFlowScalar
+>(
+    origInput: Tensor<Tinput>,
+    origOutput: Tensor<Tinput>,
+    grad: Tensor<T>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat1 = .ndhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MaxPool3DGrad", nOutputs)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("TInput", Tinput.tensorFlowDataType)
+    op.addInput(origInput)
+    op.addInput(origOutput)
+    op.addInput(grad)
+    return op.execute(Int(1))
+}
+
+/// Computes second-order gradients of the maxpooling function.
+///
+/// - Parameters:
+///     - orig_input: The original input tensor.
+///     - orig_output: The original output tensor.
+///     - grad: Output backprop of shape `[batch, depth, rows, cols, channels]`.
+///
+/// - Attrs:
+///     - ksize: 1-D tensor of length 5. The size of the window for each dimension of
+///         the input tensor. Must have `ksize[0] = ksize[4] = 1`.
+///     - strides: 1-D tensor of length 5. The stride of the sliding window for each
+///         dimension of `input`. Must have `strides[0] = strides[4] = 1`.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: The data format of the input and output data. With the
+///         default format "NDHWC", the data is stored in the order of:
+///             [batch, in_depth, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCDHW", the data storage order is:
+///             [batch, in_channels, in_depth, in_height, in_width].
+///
+/// - Output output: Gradients of gradients w.r.t. the input to `max_pool`.
+@inlinable @inline(__always)
+public static func maxPool3DGradGrad<T: Numeric & TensorFlowScalar>(
+    origInput: Tensor<T>,
+    origOutput: Tensor<T>,
+    grad: Tensor<T>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat1 = .ndhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MaxPool3DGradGrad", nOutputs)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(origInput)
+    op.addInput(origOutput)
+    op.addInput(grad)
+    return op.execute(Int(1))
+}
+
+/// Computes gradients of the maxpooling function.
+///
+/// - Parameters:
+///     - orig_input: The original input tensor.
+///     - orig_output: The original output tensor.
+///     - grad: 4-D.  Gradients w.r.t. the output of `max_pool`.
+///
+/// - Attrs:
+///     - ksize: The size of the window for each dimension of the input tensor.
+///     - strides: The stride of the sliding window for each dimension of the
+///         input tensor.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, in_channels, in_height, in_width].
+///
+/// - Output output: Gradients w.r.t. the input to `max_pool`.
+@inlinable @inline(__always)
+public static func maxPoolGrad<T: Numeric & TensorFlowScalar>(
+    origInput: Tensor<T>,
+    origOutput: Tensor<T>,
+    grad: Tensor<T>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MaxPoolGrad", nOutputs)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(origInput)
+    op.addInput(origOutput)
+    op.addInput(grad)
+    return op.execute(Int(1))
+}
+
+/// Computes second-order gradients of the maxpooling function.
+///
+/// - Parameters:
+///     - orig_input: The original input tensor.
+///     - orig_output: The original output tensor.
+///     - grad: 4-D.  Gradients of gradients w.r.t. the input of `max_pool`.
+///
+/// - Attrs:
+///     - ksize: The size of the window for each dimension of the input tensor.
+///     - strides: The stride of the sliding window for each dimension of the
+///         input tensor.
+///     - padding: The type of padding algorithm to use.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, in_channels, in_height, in_width].
+///
+/// - Output output: Gradients of gradients w.r.t. the input to `max_pool`.
+@inlinable @inline(__always)
+public static func maxPoolGradGrad<T: Numeric & TensorFlowScalar>(
+    origInput: Tensor<T>,
+    origOutput: Tensor<T>,
+    grad: Tensor<T>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MaxPoolGradGrad", nOutputs)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(origInput)
+    op.addInput(origOutput)
+    op.addInput(grad)
+    return op.execute(Int(1))
+}
+
+/// Computes second-order gradients of the maxpooling function.
+///
+/// - Parameters:
+///     - orig_input: The original input tensor.
+///     - orig_output: The original output tensor.
+///     - grad: 4-D.  Gradients of gradients w.r.t. the input of `max_pool`.
+///     - ksize: The size of the window for each dimension of the input tensor.
+///     - strides: The stride of the sliding window for each dimension of the
+///         input tensor.
+///
+/// - Attrs:
+///     - padding: The type of padding algorithm to use.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, in_channels, in_height, in_width].
+///
+/// - Output output: Gradients of gradients w.r.t. the input to `max_pool`.
+@inlinable @inline(__always)
+public static func maxPoolGradGradV2<T: Numeric & TensorFlowScalar>(
+    origInput: Tensor<T>,
+    origOutput: Tensor<T>,
+    grad: Tensor<T>,
+    ksize: Tensor<Int32>,
+    strides: Tensor<Int32>,
+    padding: Padding,
+    dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MaxPoolGradGradV2", nOutputs)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(origInput)
+    op.addInput(origOutput)
+    op.addInput(grad)
+    op.addInput(ksize)
+    op.addInput(strides)
+    return op.execute(Int(1))
+}
+
+/// Computes second-order gradients of the maxpooling function.
+///
+/// - Parameters:
+///     - input: The original input.
+///     - grad: 4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t. the
+///         input of `max_pool`.
+///     - argmax: The indices of the maximum values chosen for each output of `max_pool`.
+///
+/// - Attrs:
+///     - ksize: The size of the window for each dimension of the input tensor.
+///     - strides: The stride of the sliding window for each dimension of the
+///         input tensor.
+///     - padding: The type of padding algorithm to use.
+///     - include_batch_in_index: Whether to include batch dimension in flattened index of `argmax`.
+///
+/// - Output output: Gradients of gradients w.r.t. the input of `max_pool`.
+@inlinable @inline(__always)
+public static func maxPoolGradGradWithArgmax<
+    Targmax: BinaryInteger & TensorFlowScalar,
+    T: Numeric & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    grad: Tensor<T>,
+    argmax: Tensor<Targmax>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    includeBatchInIndex: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MaxPoolGradGradWithArgmax", nOutputs)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("include_batch_in_index", includeBatchInIndex)
+    op.updateAttribute("Targmax", Targmax.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(grad)
+    op.addInput(argmax)
+    return op.execute(Int(1))
+}
+
+/// Computes gradients of the maxpooling function.
+///
+/// - Parameters:
+///     - orig_input: The original input tensor.
+///     - orig_output: The original output tensor.
+///     - grad: 4-D.  Gradients w.r.t. the output of `max_pool`.
+///     - ksize: The size of the window for each dimension of the input tensor.
+///     - strides: The stride of the sliding window for each dimension of the
+///         input tensor.
+///
+/// - Attrs:
+///     - padding: The type of padding algorithm to use.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, in_channels, in_height, in_width].
+///
+/// - Output output: Gradients w.r.t. the input to `max_pool`.
+@inlinable @inline(__always)
+public static func maxPoolGradV2<T: Numeric & TensorFlowScalar>(
+    origInput: Tensor<T>,
+    origOutput: Tensor<T>,
+    grad: Tensor<T>,
+    ksize: Tensor<Int32>,
+    strides: Tensor<Int32>,
+    padding: Padding,
+    dataFormat: DataFormat = .nhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MaxPoolGradV2", nOutputs)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(origInput)
+    op.addInput(origOutput)
+    op.addInput(grad)
+    op.addInput(ksize)
+    op.addInput(strides)
+    return op.execute(Int(1))
+}
+
+/// Computes gradients of the maxpooling function.
+///
+/// - Parameters:
+///     - input: The original input.
+///     - grad: 4-D with shape `[batch, height, width, channels]`.  Gradients w.r.t. the
+///         output of `max_pool`.
+///     - argmax: The indices of the maximum values chosen for each output of `max_pool`.
+///
+/// - Attrs:
+///     - ksize: The size of the window for each dimension of the input tensor.
+///     - strides: The stride of the sliding window for each dimension of the
+///         input tensor.
+///     - padding: The type of padding algorithm to use.
+///     - include_batch_in_index: Whether to include batch dimension in flattened index of `argmax`.
+///
+/// - Output output: Gradients w.r.t. the input of `max_pool`.
+@inlinable @inline(__always)
+public static func maxPoolGradWithArgmax<
+    Targmax: BinaryInteger & TensorFlowScalar,
+    T: Numeric & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    grad: Tensor<T>,
+    argmax: Tensor<Targmax>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    includeBatchInIndex: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MaxPoolGradWithArgmax", nOutputs)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("include_batch_in_index", includeBatchInIndex)
+    op.updateAttribute("Targmax", Targmax.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(grad)
+    op.addInput(argmax)
+    return op.execute(Int(1))
+}
+
+/// Performs max pooling on the input.
+///
+/// - Parameters:
+///     - input: 4-D input to pool over.
+///     - ksize: The size of the window for each dimension of the input tensor.
+///     - strides: The stride of the sliding window for each dimension of the
+///         input tensor.
+///
+/// - Attrs:
+///     - padding: The type of padding algorithm to use.
+///     - data_format: Specify the data format of the input and output data. With the
+///         default format "NHWC", the data is stored in the order of:
+///             [batch, in_height, in_width, in_channels].
+///         Alternatively, the format could be "NCHW", the data storage order of:
+///             [batch, in_channels, in_height, in_width].
+///
+/// - Output output: The max pooled output tensor.
+@inlinable @inline(__always)
+public static func maxPoolV2<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    ksize: Tensor<Int32>,
+    strides: Tensor<Int32>,
+    padding: Padding,
+    dataFormat: DataFormat4 = .nhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MaxPoolV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.addInput(input)
+    op.addInput(ksize)
+    op.addInput(strides)
+    return op.execute(Int(1))
+}
+
+/// Performs max pooling on the input and outputs both max values and indices.
+///
+/// The indices in `argmax` are flattened, so that a maximum value at position
+/// `[b, y, x, c]` becomes flattened index:
+/// `(y * width + x) * channels + c` if `include_batch_in_index` is False;
+/// `((b * height + y) * width + x) * channels + c` if `include_batch_in_index` is True.
+///
+/// The indices returned are always in `[0, height) x [0, width)` before flattening,
+/// even if padding is involved and the mathematically correct answer is outside
+/// (either negative or too large).  This is a bug, but fixing it is difficult to do
+/// in a safe backwards compatible way, especially due to flattening.
+///
+/// - Parameter input: 4-D with shape `[batch, height, width, channels]`.  Input to pool over.
+///
+/// - Attrs:
+///     - ksize: The size of the window for each dimension of the input tensor.
+///     - strides: The stride of the sliding window for each dimension of the
+///         input tensor.
+///     - padding: The type of padding algorithm to use.
+///     - include_batch_in_index: Whether to include batch dimension in flattened index of `argmax`.
+///
+/// - Outputs:
+///     - output: The max pooled output tensor.
+///     - argmax: 4-D.  The flattened indices of the max values chosen for each output.
+@inlinable @inline(__always)
+public static func maxPoolWithArgmax<
+    Targmax: BinaryInteger & TensorFlowScalar,
+    T: Numeric & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding,
+    includeBatchInIndex: Bool = false
+) -> (output: Tensor<T>, argmax: Tensor<Targmax>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("MaxPoolWithArgmax", nOutputs)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("Targmax", Targmax.tensorFlowDataType)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("include_batch_in_index", includeBatchInIndex)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Returns the max of x and y (i.e. x > y ? x : y) element-wise.
+///
+/// *NOTE*: `Maximum` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func maximum<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Maximum", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Computes the mean of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///     - input: The tensor to reduce.
+///     - reduction_indices: The dimensions to reduce. Must be in the range
+///         `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func mean<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    reductionIndices: Tensor<Tidx>,
+    keepDims: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Mean", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(reductionIndices)
+    return op.execute(Int(1))
+}
+
+/// Forwards the value of an available tensor from `inputs` to `output`.
+///
+/// `Merge` waits for at least one of the tensors in `inputs` to become available.
+/// It is usually combined with `Switch` to implement branching.
+///
+/// `Merge` forwards the first tensor to become available to `output`, and sets
+/// `value_index` to its index in `inputs`.
+///
+/// - Parameter inputs: The input tensors, exactly one of which will become available.
+///
+/// - Outputs:
+///     - output: Will be set to the available input tensor.
+///     - value_index: The index of the chosen input tensor in `inputs`.
+@inlinable @inline(__always)
+public static func merge<T: TensorFlowScalar>(
+    inputs: [Tensor<T>]
+) -> (output: Tensor<T>, valueIndex: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("Merge", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("N", inputs.count)
+    op.addInputList(inputs)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Merges summaries.
+///
+/// This op creates a
+/// [`Summary`](https://www.tensorflow.org/code/tensorflow/core/framework/summary.proto)
+/// protocol buffer that contains the union of all the values in the input
+/// summaries.
+///
+/// When the Op is run, it reports an `InvalidArgument` error if multiple values
+/// in the summaries to merge use the same tag.
+///
+/// - Parameter inputs: Can be of any shape.  Each must contain serialized `Summary` protocol
+///     buffers.
+///
+/// - Output summary: Scalar. Serialized `Summary` protocol buffer.
+@inlinable @inline(__always)
+public static func mergeSummary(
+    inputs: [StringTensor]
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("MergeSummary", nOutputs)
+    op.updateAttribute("N", inputs.count)
+    op.addInputList(inputs)
+    return op.execute(Int(1))
+}
+
+/// V2 format specific: merges the metadata files of sharded checkpoints.  The
+///
+/// result is one logical checkpoint, with one physical metadata file and renamed
+/// data files.
+///
+/// Intended for "grouping" multiple checkpoints in a sharded checkpoint setup.
+///
+/// If delete_old_dirs is true, attempts to delete recursively the dirname of each
+/// path in the input checkpoint_prefixes.  This is useful when those paths are non
+/// user-facing temporary locations.
+///
+/// - Parameters:
+///     - checkpoint_prefixes: prefixes of V2 checkpoints to merge.
+///     - destination_prefix: scalar.  The desired final prefix.  Allowed to be the same
+///         as one of the checkpoint_prefixes.
+///
+/// - Attr delete_old_dirs: see above.
+@inlinable @inline(__always)
+public static func mergeV2Checkpoints(
+    checkpointPrefixes: StringTensor,
+    destinationPrefix: StringTensor,
+    deleteOldDirs: Bool = true
+) {
+  let nOutputs = 0
+    let op = makeOp("MergeV2Checkpoints", nOutputs)
+    op.updateAttribute("delete_old_dirs", deleteOldDirs)
+    op.addInput(checkpointPrefixes)
+    op.addInput(destinationPrefix)
+    op.execute()
+}
+
+/// Transforms a spectrogram into a form that's useful for speech recognition.
+///
+/// Mel Frequency Cepstral Coefficients are a way of representing audio data that's
+/// been effective as an input feature for machine learning. They are created by
+/// taking the spectrum of a spectrogram (a 'cepstrum'), and discarding some of the
+/// higher frequencies that are less significant to the human ear. They have a long
+/// history in the speech recognition world, and https://en.wikipedia.org/wiki/Mel-frequency_cepstrum
+/// is a good resource to learn more.
+///
+/// - Parameters:
+///     - spectrogram: Typically produced by the Spectrogram op, with magnitude_squared
+///         set to true.
+///     - sample_rate: How many samples per second the source audio used.
+///
+/// - Attrs:
+///     - upper_frequency_limit: The highest frequency to use when calculating the
+///         ceptstrum.
+///     - lower_frequency_limit: The lowest frequency to use when calculating the
+///         ceptstrum.
+///     - filterbank_channel_count: Resolution of the Mel bank used internally.
+///     - dct_coefficient_count: How many output channels to produce per time slice.
+@inlinable @inline(__always)
+public static func mfcc(
+    spectrogram: Tensor<Float>,
+    sampleRate: Tensor<Int32>,
+    upperFrequencyLimit: Double = 4000,
+    lowerFrequencyLimit: Double = 20,
+    filterbankChannelCount: Int64 = 40,
+    dctCoefficientCount: Int64 = 13
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("Mfcc", nOutputs)
+    op.updateAttribute("upper_frequency_limit", upperFrequencyLimit)
+    op.updateAttribute("lower_frequency_limit", lowerFrequencyLimit)
+    op.updateAttribute("filterbank_channel_count", filterbankChannelCount)
+    op.updateAttribute("dct_coefficient_count", dctCoefficientCount)
+    op.addInput(spectrogram)
+    op.addInput(sampleRate)
+    return op.execute(Int(1))
+}
+
+/// Computes the minimum of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///     - input: The tensor to reduce.
+///     - reduction_indices: The dimensions to reduce. Must be in the range
+///         `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func min<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    reductionIndices: Tensor<Tidx>,
+    keepDims: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Min", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(reductionIndices)
+    return op.execute(Int(1))
+}
+
+/// Returns the min of x and y (i.e. x < y ? x : y) element-wise.
+///
+/// *NOTE*: `Minimum` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func minimum<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Minimum", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Pads a tensor with mirrored values.
+///
+/// This operation pads a `input` with mirrored values according to the `paddings`
+/// you specify. `paddings` is an integer tensor with shape `[n, 2]`, where n is
+/// the rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
+/// how many values to add before the contents of `input` in that dimension, and
+/// `paddings[D, 1]` indicates how many values to add after the contents of `input`
+/// in that dimension. Both `paddings[D, 0]` and `paddings[D, 1]` must be no greater
+/// than `input.dim_size(D)` (or `input.dim_size(D) - 1`) if `copy_border` is true
+/// (if false, respectively).
+///
+/// The padded size of each dimension D of the output is:
+///
+/// `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[1, 2, 3], [4, 5, 6]].
+/// # 'paddings' is [[1, 1]], [2, 2]].
+/// # 'mode' is SYMMETRIC.
+/// # rank of 't' is 2.
+/// pad(t, paddings) ==> [[2, 1, 1, 2, 3, 3, 2]
+///                       [2, 1, 1, 2, 3, 3, 2]
+///                       [5, 4, 4, 5, 6, 6, 5]
+///                       [5, 4, 4, 5, 6, 6, 5]]
+/// ```
+///
+/// - Parameters:
+///     - input: The input tensor to be padded.
+///     - paddings: A two-column matrix specifying the padding sizes. The number of
+///         rows must be the same as the rank of `input`.
+///
+/// - Attr mode: Either `REFLECT` or `SYMMETRIC`. In reflect mode the padded regions
+///     do not include the borders, while in symmetric mode the padded regions
+///     do include the borders. For example, if `input` is `[1, 2, 3]` and `paddings`
+///     is `[0, 2]`, then the output is `[1, 2, 3, 2, 1]` in reflect mode, and
+///     it is `[1, 2, 3, 3, 2]` in symmetric mode.
+///
+/// - Output output: The padded tensor.
+@inlinable @inline(__always)
+public static func mirrorPad<
+    T: TensorFlowScalar,
+    Tpaddings: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    paddings: Tensor<Tpaddings>,
+    mode: Mode5
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MirrorPad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tpaddings", Tpaddings.tensorFlowDataType)
+    op.updateAttribute("mode", mode.cName)
+    op.addInput(input)
+    op.addInput(paddings)
+    return op.execute(Int(1))
+}
+
+/// Gradient op for `MirrorPad` op. This op folds a mirror-padded tensor.
+///
+/// This operation folds the padded areas of `input` by `MirrorPad` according to the
+/// `paddings` you specify. `paddings` must be the same as `paddings` argument
+/// given to the corresponding `MirrorPad` op.
+///
+/// The folded size of each dimension D of the output is:
+///
+/// `input.dim_size(D) - paddings(D, 0) - paddings(D, 1)`
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[1, 2, 3], [4, 5, 6], [7, 8, 9]].
+/// # 'paddings' is [[0, 1]], [0, 1]].
+/// # 'mode' is SYMMETRIC.
+/// # rank of 't' is 2.
+/// pad(t, paddings) ==> [[ 1,  5]
+///                       [11, 28]]
+/// ```
+///
+/// - Parameters:
+///     - input: The input tensor to be folded.
+///     - paddings: A two-column matrix specifying the padding sizes. The number of
+///         rows must be the same as the rank of `input`.
+///
+/// - Attr mode: The mode used in the `MirrorPad` op.
+///
+/// - Output output: The folded tensor.
+@inlinable @inline(__always)
+public static func mirrorPadGrad<
+    T: TensorFlowScalar,
+    Tpaddings: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    paddings: Tensor<Tpaddings>,
+    mode: Mode5
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MirrorPadGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tpaddings", Tpaddings.tensorFlowDataType)
+    op.updateAttribute("mode", mode.cName)
+    op.addInput(input)
+    op.addInput(paddings)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func mixedStruct(
+    nA: Int64
+) -> (a: [Tensor<Int32>], b: Tensor<Float>) {
+  let nOutputs = Int(nA) + Int(1)
+    let op = makeOp("MixedStruct", nOutputs)
+    op.updateAttribute("n_a", nA)
+    return op.execute(Int(nA), Int(1))
+}
+
+/// Returns element-wise remainder of division. This emulates C semantics in that
+///
+/// the result here is consistent with a truncating divide. E.g.
+/// `tf.truncatediv(x, y) * y + truncate_mod(x, y) = x`.
+///
+/// *NOTE*: `Mod` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func mod<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Mod", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Identity transformation that models performance.
+///
+/// Identity transformation that models performance.
+///
+/// - Parameter input_dataset: A variant tensor representing the input dataset.
+@inlinable @inline(__always)
+public static func modelDataset(
+    inputDataset: VariantHandle,
+    cpuBudget: Int64 = 0,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ModelDataset", nOutputs)
+    op.updateAttribute("cpu_budget", cpuBudget)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    return op.execute(Int(1))
+}
+
+/// Returns x * y element-wise.
+///
+/// *NOTE*: `Multiply` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func mul<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Mul", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns x * y element-wise. Returns zero if y is zero, even if x if infinite or NaN.
+///
+/// *NOTE*: `Mul` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func mulNoNan<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("MulNoNan", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Creates a MultiDeviceIterator resource.
+///
+/// - Attrs:
+///     - devices: A list of devices the iterator works across.
+///     - shared_name: If non-empty, this resource will be shared under the given name
+///         across multiple sessions.
+///     - container: If non-empty, this resource is placed in the given container.
+///         Otherwise, a default container is used.
+///     - output_types: The type list for the return values.
+///     - output_shapes: The list of shapes being produced.
+///
+/// - Output handle: Handle to the resource created.
+@inlinable @inline(__always)
+public static func multiDeviceIterator(
+    devices: [String],
+    sharedName: String,
+    container: String,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("MultiDeviceIterator", nOutputs)
+    op.updateAttribute("devices", devices)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("container", container)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    return op.execute(Int(1))
+}
+
+/// Generates a MultiDeviceIterator resource from its provided string handle.
+///
+/// - Parameter string_handle: String representing the resource.
+///
+/// - Attrs:
+///     - output_types: The type list for the return values.
+///     - output_shapes: The list of shapes being produced.
+///
+/// - Output multi_device_iterator: A MultiDeviceIterator resource.
+@inlinable @inline(__always)
+public static func multiDeviceIteratorFromStringHandle(
+    stringHandle: StringTensor,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("MultiDeviceIteratorFromStringHandle", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(stringHandle)
+    return op.execute(Int(1))
+}
+
+/// Gets next element for the provided shard number.
+///
+/// - Parameters:
+///     - multi_device_iterator: A MultiDeviceIterator resource.
+///     - shard_num: Integer representing which shard to fetch data for.
+///     - incarnation_id: Which incarnation of the MultiDeviceIterator is running.
+///
+/// - Attrs:
+///     - output_types: The type list for the return values.
+///     - output_shapes: The list of shapes being produced.
+///
+/// - Output components: Result of the get_next on the dataset.
+@inlinable @inline(__always)
+public static func multiDeviceIteratorGetNextFromShard<OutputTypes: TensorGroup>(
+    multiDeviceIterator: ResourceHandle,
+    shardNum: Tensor<Int32>,
+    incarnationId: Tensor<Int64>,
+    outputShapes: [TensorShape?]
+) -> OutputTypes {
+  let nOutputs = Int(OutputTypes._typeList.count)
+    let op = makeOp("MultiDeviceIteratorGetNextFromShard", nOutputs)
+    op.updateAttribute("output_types", OutputTypes._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(multiDeviceIterator)
+    op.addInput(shardNum)
+    op.addInput(incarnationId)
+    return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Initializes the multi device iterator with the given dataset.
+///
+/// - Parameters:
+///     - dataset: Dataset to be iterated upon.
+///     - multi_device_iterator: A MultiDeviceIteratorResource.
+///     - max_buffer_size: The maximum size of the host side per device buffer to keep.
+///
+/// - Output incarnation_id: An int64 indicating which incarnation of the MultiDeviceIterator
+///     is running.
+@inlinable @inline(__always)
+public static func multiDeviceIteratorInit(
+    dataset: VariantHandle,
+    multiDeviceIterator: ResourceHandle,
+    maxBufferSize: Tensor<Int64>
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("MultiDeviceIteratorInit", nOutputs)
+    op.addInput(dataset)
+    op.addInput(multiDeviceIterator)
+    op.addInput(maxBufferSize)
+    return op.execute(Int(1))
+}
+
+/// Produces a string handle for the given MultiDeviceIterator.
+///
+/// - Parameter multi_device_iterator: A MultiDeviceIterator resource.
+///
+/// - Output string_handle: A string representing the resource.
+@inlinable @inline(__always)
+public static func multiDeviceIteratorToStringHandle(
+    multiDeviceIterator: ResourceHandle
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("MultiDeviceIteratorToStringHandle", nOutputs)
+    op.addInput(multiDeviceIterator)
+    return op.execute(Int(1))
+}
+
+/// Draws samples from a multinomial distribution.
+///
+/// - Parameters:
+///     - logits: 2-D Tensor with shape `[batch_size, num_classes]`.  Each slice `[i, :]`
+///         represents the unnormalized log probabilities for all classes.
+///     - num_samples: 0-D.  Number of independent samples to draw for each row slice.
+///
+/// - Attrs:
+///     - seed: If either seed or seed2 is set to be non-zero, the internal random number
+///         generator is seeded by the given seed.  Otherwise, a random seed is used.
+///     - seed2: A second seed to avoid seed collision.
+///
+/// - Output output: 2-D Tensor with shape `[batch_size, num_samples]`.  Each slice `[i, :]`
+///     contains the drawn class labels with range `[0, num_classes)`.
+@inlinable @inline(__always)
+public static func multinomial<
+    T: Numeric & TensorFlowScalar,
+    OutputDtype: BinaryInteger & TensorFlowScalar
+>(
+    logits: Tensor<T>,
+    numSamples: Tensor<Int32>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<OutputDtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("Multinomial", nOutputs)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("output_dtype", OutputDtype.tensorFlowDataType)
+    op.addInput(logits)
+    op.addInput(numSamples)
+    return op.execute(Int(1))
+}
+
+/// Creates an empty hash table that uses tensors as the backing store.
+///
+/// It uses "open addressing" with quadratic reprobing to resolve
+/// collisions.
+///
+/// This op creates a mutable hash table, specifying the type of its keys and
+/// values. Each value must be a scalar. Data can be inserted into the table using
+/// the insert operations. It does not support the initialization operation.
+///
+/// - Parameter empty_key: The key used to represent empty key buckets internally. Must not
+///     be used in insert or lookup operations.
+///
+/// - Attrs:
+///     - container: If non-empty, this table is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this table is shared under the given name across
+///         multiple sessions.
+///     - key_dtype: Type of the table keys.
+///     - value_dtype: Type of the table values.
+///     - value_shape: The shape of each value.
+///     - initial_num_buckets: The initial number of hash table buckets. Must be a power
+///         to 2.
+///     - max_load_factor: The maximum ratio between number of entries and number of
+///         buckets before growing the table. Must be between 0 and 1.
+///
+/// - Output table_handle: Handle to a table.
+@inlinable @inline(__always)
+public static func mutableDenseHashTableV2<KeyDtype: TensorFlowScalar>(
+    emptyKey: Tensor<KeyDtype>,
+    deletedKey: Tensor<KeyDtype>,
+    container: String,
+    sharedName: String,
+    useNodeNameSharing: Bool = false,
+    valueDtype: TensorDataType,
+    valueShape: TensorShape?,
+    initialNumBuckets: Int64 = 131072,
+    maxLoadFactor: Double = 0.8
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("MutableDenseHashTableV2", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("use_node_name_sharing", useNodeNameSharing)
+    op.updateAttribute("key_dtype", KeyDtype.tensorFlowDataType)
+    op.updateAttribute("value_dtype", valueDtype)
+    op.updateAttribute("value_shape", valueShape)
+    op.updateAttribute("initial_num_buckets", initialNumBuckets)
+    op.updateAttribute("max_load_factor", maxLoadFactor)
+    op.addInput(emptyKey)
+    op.addInput(deletedKey)
+    return op.execute(Int(1))
+}
+
+/// Creates an empty hash table.
+///
+/// This op creates a mutable hash table, specifying the type of its keys and
+/// values. Each value must be a vector. Data can be inserted into the table using
+/// the insert operations. It does not support the initialization operation.
+///
+/// - Attrs:
+///     - container: If non-empty, this table is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this table is shared under the given name across
+///         multiple sessions.
+///     - key_dtype: Type of the table keys.
+///     - value_dtype: Type of the table values.
+///
+/// - Output table_handle: Handle to a table.
+@inlinable @inline(__always)
+public static func mutableHashTableOfTensorsV2(
+    container: String,
+    sharedName: String,
+    useNodeNameSharing: Bool = false,
+    keyDtype: TensorDataType,
+    valueDtype: TensorDataType,
+    valueShape: TensorShape?
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("MutableHashTableOfTensorsV2", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("use_node_name_sharing", useNodeNameSharing)
+    op.updateAttribute("key_dtype", keyDtype)
+    op.updateAttribute("value_dtype", valueDtype)
+    op.updateAttribute("value_shape", valueShape)
+    return op.execute(Int(1))
+}
+
+/// Creates an empty hash table.
+///
+/// This op creates a mutable hash table, specifying the type of its keys and
+/// values. Each value must be a scalar. Data can be inserted into the table using
+/// the insert operations. It does not support the initialization operation.
+///
+/// - Attrs:
+///     - container: If non-empty, this table is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this table is shared under the given name across
+///         multiple sessions.
+///     - use_node_name_sharing: If true and shared_name is empty, the table is shared
+///         using the node name.
+///     - key_dtype: Type of the table keys.
+///     - value_dtype: Type of the table values.
+///
+/// - Output table_handle: Handle to a table.
+@inlinable @inline(__always)
+public static func mutableHashTableV2(
+    container: String,
+    sharedName: String,
+    useNodeNameSharing: Bool = false,
+    keyDtype: TensorDataType,
+    valueDtype: TensorDataType
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("MutableHashTableV2", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("use_node_name_sharing", useNodeNameSharing)
+    op.updateAttribute("key_dtype", keyDtype)
+    op.updateAttribute("value_dtype", valueDtype)
+    return op.execute(Int(1))
+}
+
+/// Locks a mutex resource.  The output is the lock.  So long as the lock tensor
+///
+/// is alive, any other request to use `MutexLock` with this mutex will wait.
+///
+/// This is particularly useful for creating a critical section when used in
+/// conjunction with `MutexLockIdentity`:
+///
+/// ```python
+///
+/// mutex = mutex_v2(
+///   shared_name=handle_name, container=container, name=name)
+///
+/// def execute_in_critical_section(fn, *args, **kwargs):
+///   lock = gen_resource_variable_ops.mutex_lock(mutex)
+///
+///   with ops.control_dependencies([lock]):
+///     r = fn(*args, **kwargs)
+///
+///   with ops.control_dependencies(nest.flatten(r)):
+///     with ops.colocate_with(mutex):
+///       ensure_lock_exists = mutex_lock_identity(lock)
+///
+///     # Make sure that if any element of r is accessed, all of
+///     # them are executed together.
+///     r = nest.map_structure(tf.identity, r)
+///
+///   with ops.control_dependencies([ensure_lock_exists]):
+///     return nest.map_structure(tf.identity, r)
+/// ```
+///
+/// While `fn` is running in the critical section, no other functions which wish to
+/// use this critical section may run.
+///
+/// Often the use case is that two executions of the same graph, in parallel,
+/// wish to run `fn`; and we wish to ensure that only one of them executes
+/// at a time.  This is especially important if `fn` modifies one or more
+/// variables at a time.
+///
+/// It is also useful if two separate functions must share a resource, but we
+/// wish to ensure the usage is exclusive.
+///
+/// - Parameter mutex: The mutex resource to lock.
+///
+/// - Output mutex_lock: A tensor that keeps a shared pointer to a lock on the mutex;
+///     when the Tensor is destroyed, the use count on the shared pointer is decreased
+///     by 1.  When it reaches 0, the lock is released.
+@inlinable @inline(__always)
+public static func mutexLock(
+    mutex: ResourceHandle
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("MutexLock", nOutputs)
+    op.addInput(mutex)
+    return op.execute(Int(1))
+}
+
+/// Creates a Mutex resource that can be locked by `MutexLock`.
+///
+/// - Attrs:
+///     - container: If non-empty, this variable is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this variable is named in the given bucket
+///         with this shared_name. Otherwise, the node name is used instead.
+///
+/// - Output resource: The mutex resource.
+@inlinable @inline(__always)
+public static func mutexV2(
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("MutexV2", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func nInPolymorphicTwice<T: TensorFlowScalar>(
+    _ a: [Tensor<T>],
+    _ b: [Tensor<T>]
+) {
+  let nOutputs = 0
+    let op = makeOp("NInPolymorphicTwice", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("N", a.count)
+    op.addInputList(a)
+    op.addInputList(b)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nInTwice(
+    _ a: [Tensor<Int32>],
+    _ b: [StringTensor]
+) {
+  let nOutputs = 0
+    let op = makeOp("NInTwice", nOutputs)
+    op.updateAttribute("N", a.count)
+    op.addInputList(a)
+    op.addInputList(b)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nInTwoTypeVariables<
+    S: TensorFlowScalar,
+    T: TensorFlowScalar
+>(
+    _ a: [Tensor<S>],
+    _ b: [Tensor<T>]
+) {
+  let nOutputs = 0
+    let op = makeOp("NInTwoTypeVariables", nOutputs)
+    op.updateAttribute("S", S.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("N", a.count)
+    op.addInputList(a)
+    op.addInputList(b)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nIntsIn(
+    _ a: [Tensor<Int32>]
+) {
+  let nOutputs = 0
+    let op = makeOp("NIntsIn", nOutputs)
+    op.updateAttribute("N", a.count)
+    op.addInputList(a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nIntsOut(
+    n: Int64
+) -> [Tensor<Int32>] {
+  let nOutputs = Int(n)
+    let op = makeOp("NIntsOut", nOutputs)
+    op.updateAttribute("N", n)
+    return op.execute(Int(n))
+}
+
+@inlinable @inline(__always)
+public static func nIntsOutDefault(
+    n: Int64 = 3
+) -> [Tensor<Int32>] {
+  let nOutputs = Int(n)
+    let op = makeOp("NIntsOutDefault", nOutputs)
+    op.updateAttribute("N", n)
+    return op.execute(Int(n))
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicIn<T: TensorFlowScalar>(
+    _ a: [Tensor<T>]
+) {
+  let nOutputs = 0
+    let op = makeOp("NPolymorphicIn", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("N", a.count)
+    op.addInputList(a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicOut<T: TensorFlowScalar>(
+    n: Int64
+) -> [Tensor<T>] {
+  let nOutputs = Int(n)
+    let op = makeOp("NPolymorphicOut", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("N", n)
+    return op.execute(Int(n))
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicOutDefault<T: TensorFlowScalar>(
+    n: Int64 = 2
+) -> [Tensor<T>] {
+  let nOutputs = Int(n)
+    let op = makeOp("NPolymorphicOutDefault", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("N", n)
+    return op.execute(Int(n))
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicRestrictIn<T: TensorFlowScalar>(
+    _ a: [Tensor<T>]
+) {
+  let nOutputs = 0
+    let op = makeOp("NPolymorphicRestrictIn", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("N", a.count)
+    op.addInputList(a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicRestrictIn(
+    _ a: [StringTensor]
+) {
+  let nOutputs = 0
+    let op = makeOp("NPolymorphicRestrictIn", nOutputs)
+    op.updateAttribute("T", TensorDataType(TF_STRING))
+    op.updateAttribute("N", a.count)
+    op.addInputList(a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicRestrictOut<T: TensorFlowScalar>(
+    n: Int64
+) -> [Tensor<T>] {
+  let nOutputs = Int(n)
+    let op = makeOp("NPolymorphicRestrictOut", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("N", n)
+    return op.execute(Int(n))
+}
+
+@inlinable @inline(__always)
+public static func nPolymorphicRestrictOut(
+    n: Int64
+) -> [StringTensor] {
+  let nOutputs = Int(n)
+    let op = makeOp("NPolymorphicRestrictOut", nOutputs)
+    op.updateAttribute("T", TensorDataType(TF_STRING))
+    op.updateAttribute("N", n)
+    return op.execute(Int(n))
+}
+
+/// Outputs a tensor containing the reduction across all input tensors.
+///
+/// Outputs a tensor containing the reduction across all input tensors passed to ops
+/// within the same `shared_name.
+///
+/// The graph should be constructed so if one op runs with shared_name value `c`,
+/// then `num_devices` ops will run with shared_name value `c`.  Failure to do so
+/// will cause the graph execution to fail to complete.
+///
+/// input: the input to the reduction
+/// data: the value of the reduction across all `num_devices` devices.
+/// reduction: the reduction operation to perform.
+/// num_devices: The number of devices participating in this reduction.
+/// shared_name: Identifier that shared between ops of the same reduction.
+@inlinable @inline(__always)
+public static func ncclAllReduce<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    reduction: Reduction,
+    numDevices: Int64,
+    sharedName: String
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("NcclAllReduce", nOutputs)
+    op.updateAttribute("reduction", reduction.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("num_devices", numDevices)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Sends `input` to all devices that are connected to the output.
+///
+/// Sends `input` to all devices that are connected to the output.
+///
+/// The graph should be constructed so that all ops connected to the output have a
+/// valid device assignment, and the op itself is assigned one of these devices.
+///
+/// input: The input to the broadcast.
+/// output: The same as input.
+/// shape: The shape of the input tensor.
+///
+@inlinable @inline(__always)
+public static func ncclBroadcast<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    shape: TensorShape?
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("NcclBroadcast", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("shape", shape)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Reduces `input` from `num_devices` using `reduction` to a single device.
+///
+/// Reduces `input` from `num_devices` using `reduction` to a single device.
+///
+/// The graph should be constructed so that all inputs have a valid device
+/// assignment, and the op itself is assigned one of these devices.
+///
+/// input: The input to the reduction.
+/// data: the value of the reduction across all `num_devices` devices.
+/// reduction: the reduction operation to perform.
+@inlinable @inline(__always)
+public static func ncclReduce<T: Numeric & TensorFlowScalar>(
+    _ input: [Tensor<T>],
+    reduction: Reduction
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("NcclReduce", nOutputs)
+    op.updateAttribute("reduction", reduction.cName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("num_devices", input.count)
+    op.addInputList(input)
+    return op.execute(Int(1))
+}
+
+/// Selects the k nearest centers for each point.
+///
+/// Rows of points are assumed to be input points. Rows of centers are assumed to be
+/// the list of candidate centers. For each point, the k centers that have least L2
+/// distance to it are computed.
+///
+/// - Parameters:
+///     - points: Matrix of shape (n, d). Rows are assumed to be input points.
+///     - centers: Matrix of shape (m, d). Rows are assumed to be centers.
+///     - k: Number of nearest centers to return for each point. If k is larger than m, then
+///         only m centers are returned.
+///
+/// - Outputs:
+///     - nearest_center_indices: Matrix of shape (n, min(m, k)). Each row contains the indices of the centers
+///         closest to the corresponding point, ordered by increasing distance.
+///     - nearest_center_distances: Matrix of shape (n, min(m, k)). Each row contains the squared L2 distance to the
+///         corresponding center in nearest_center_indices.
+@inlinable @inline(__always)
+public static func nearestNeighbors(
+    points: Tensor<Float>,
+    centers: Tensor<Float>,
+    k: Tensor<Int64>
+) -> (nearestCenterIndices: Tensor<Int64>, nearestCenterDistances: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("NearestNeighbors", nOutputs)
+    op.addInput(points)
+    op.addInput(centers)
+    op.addInput(k)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Computes numerical negative value element-wise.
+///
+/// I.e., \\(y = -x\\).
+@inlinable @inline(__always)
+public static func neg<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Neg", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns the next representable value of `x1` in the direction of `x2`, element-wise.
+///
+/// This operation returns the same result as the C++ std::nextafter function.
+///
+/// It can also return a subnormal number.
+///
+/// @compatibility(cpp)
+/// Equivalent to C++ std::nextafter function.
+/// @end_compatibility
+@inlinable @inline(__always)
+public static func nextAfter<T: FloatingPoint & TensorFlowScalar>(
+    x1: Tensor<T>,
+    x2: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("NextAfter", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x1)
+    op.addInput(x2)
+    return op.execute(Int(1))
+}
+
+/// Makes its input available to the next iteration.
+///
+/// - Parameter data: The tensor to be made available to the next iteration.
+///
+/// - Output output: The same tensor as `data`.
+@inlinable @inline(__always)
+public static func nextIteration<T: TensorFlowScalar>(
+    data: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("NextIteration", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(data)
+    return op.execute(Int(1))
+}
+
+/// Does nothing. Only useful as a placeholder for control edges.
+@inlinable @inline(__always)
+public static func noOp(
+) {
+  let nOutputs = 0
+    let op = makeOp("NoOp", nOutputs)
+    
+    op.execute()
+}
+
+/// Non-deterministically generates some integers.
+///
+/// This op may use some OS-provided source of non-determinism (e.g. an RNG), so each execution will give different results.
+///
+/// - Parameter shape: The shape of the output tensor.
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Non-deterministic integer values with specified shape.
+@inlinable @inline(__always)
+public static func nonDeterministicInts<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+    shape: Tensor<ShapeDtype>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("NonDeterministicInts", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape_dtype", ShapeDtype.tensorFlowDataType)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Greedily selects a subset of bounding boxes in descending order of score,
+///
+/// pruning away boxes that have high intersection-over-union (IOU) overlap
+/// with previously selected boxes.  Bounding boxes are supplied as
+/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+/// diagonal pair of box corners and the coordinates can be provided as normalized
+/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+/// is agnostic to where the origin is in the coordinate system.  Note that this
+/// algorithm is invariant to orthogonal transformations and translations
+/// of the coordinate system; thus translating or reflections of the coordinate
+/// system result in the same boxes being selected by the algorithm.
+/// The output of this operation is a set of integers indexing into the input
+/// collection of bounding boxes representing the selected boxes.  The bounding
+/// box coordinates corresponding to the selected indices can then be obtained
+/// using the `tf.gather operation`.  For example:
+///   selected_indices = tf.image.non_max_suppression(
+///       boxes, scores, max_output_size, iou_threshold)
+///   selected_boxes = tf.gather(boxes, selected_indices)
+///
+/// - Parameters:
+///     - boxes: A 2-D float tensor of shape `[num_boxes, 4]`.
+///     - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
+///         score corresponding to each box (each row of boxes).
+///     - max_output_size: A scalar integer tensor representing the maximum number of
+///         boxes to be selected by non max suppression.
+///
+/// - Attr iou_threshold: A float representing the threshold for deciding whether boxes
+///     overlap too much with respect to IOU.
+///
+/// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
+///     indices from the boxes tensor, where `M <= max_output_size`.
+@inlinable @inline(__always)
+public static func nonMaxSuppression(
+    boxes: Tensor<Float>,
+    scores: Tensor<Float>,
+    maxOutputSize: Tensor<Int32>,
+    iouThreshold: Double = 0.5
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("NonMaxSuppression", nOutputs)
+    op.updateAttribute("iou_threshold", iouThreshold)
+    op.addInput(boxes)
+    op.addInput(scores)
+    op.addInput(maxOutputSize)
+    return op.execute(Int(1))
+}
+
+/// Greedily selects a subset of bounding boxes in descending order of score,
+///
+/// pruning away boxes that have high intersection-over-union (IOU) overlap
+/// with previously selected boxes.  Bounding boxes are supplied as
+/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+/// diagonal pair of box corners and the coordinates can be provided as normalized
+/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+/// is agnostic to where the origin is in the coordinate system.  Note that this
+/// algorithm is invariant to orthogonal transformations and translations
+/// of the coordinate system; thus translating or reflections of the coordinate
+/// system result in the same boxes being selected by the algorithm.
+///
+/// The output of this operation is a set of integers indexing into the input
+/// collection of bounding boxes representing the selected boxes.  The bounding
+/// box coordinates corresponding to the selected indices can then be obtained
+/// using the `tf.gather operation`.  For example:
+///
+///   selected_indices = tf.image.non_max_suppression_v2(
+///       boxes, scores, max_output_size, iou_threshold)
+///   selected_boxes = tf.gather(boxes, selected_indices)
+///
+/// - Parameters:
+///     - boxes: A 2-D float tensor of shape `[num_boxes, 4]`.
+///     - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
+///         score corresponding to each box (each row of boxes).
+///     - max_output_size: A scalar integer tensor representing the maximum number of
+///         boxes to be selected by non max suppression.
+///     - iou_threshold: A 0-D float tensor representing the threshold for deciding whether
+///         boxes overlap too much with respect to IOU.
+///
+/// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
+///     indices from the boxes tensor, where `M <= max_output_size`.
+@inlinable @inline(__always)
+public static func nonMaxSuppressionV2<T: FloatingPoint & TensorFlowScalar>(
+    boxes: Tensor<T>,
+    scores: Tensor<T>,
+    maxOutputSize: Tensor<Int32>,
+    iouThreshold: Tensor<Float>
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("NonMaxSuppressionV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(boxes)
+    op.addInput(scores)
+    op.addInput(maxOutputSize)
+    op.addInput(iouThreshold)
+    return op.execute(Int(1))
+}
+
+/// Greedily selects a subset of bounding boxes in descending order of score,
+///
+/// pruning away boxes that have high intersection-over-union (IOU) overlap
+/// with previously selected boxes.  Bounding boxes with score less than
+/// `score_threshold` are removed.  Bounding boxes are supplied as
+/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+/// diagonal pair of box corners and the coordinates can be provided as normalized
+/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+/// is agnostic to where the origin is in the coordinate system and more
+/// generally is invariant to orthogonal transformations and translations
+/// of the coordinate system; thus translating or reflections of the coordinate
+/// system result in the same boxes being selected by the algorithm.
+/// The output of this operation is a set of integers indexing into the input
+/// collection of bounding boxes representing the selected boxes.  The bounding
+/// box coordinates corresponding to the selected indices can then be obtained
+/// using the `tf.gather operation`.  For example:
+///   selected_indices = tf.image.non_max_suppression_v2(
+///       boxes, scores, max_output_size, iou_threshold, score_threshold)
+///   selected_boxes = tf.gather(boxes, selected_indices)
+///
+/// - Parameters:
+///     - boxes: A 2-D float tensor of shape `[num_boxes, 4]`.
+///     - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
+///         score corresponding to each box (each row of boxes).
+///     - max_output_size: A scalar integer tensor representing the maximum number of
+///         boxes to be selected by non max suppression.
+///     - iou_threshold: A 0-D float tensor representing the threshold for deciding whether
+///         boxes overlap too much with respect to IOU.
+///     - score_threshold: A 0-D float tensor representing the threshold for deciding when to remove
+///         boxes based on score.
+///
+/// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
+///     indices from the boxes tensor, where `M <= max_output_size`.
+@inlinable @inline(__always)
+public static func nonMaxSuppressionV3<T: FloatingPoint & TensorFlowScalar>(
+    boxes: Tensor<T>,
+    scores: Tensor<T>,
+    maxOutputSize: Tensor<Int32>,
+    iouThreshold: Tensor<Float>,
+    scoreThreshold: Tensor<Float>
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("NonMaxSuppressionV3", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(boxes)
+    op.addInput(scores)
+    op.addInput(maxOutputSize)
+    op.addInput(iouThreshold)
+    op.addInput(scoreThreshold)
+    return op.execute(Int(1))
+}
+
+/// Greedily selects a subset of bounding boxes in descending order of score,
+///
+/// pruning away boxes that have high intersection-over-union (IOU) overlap
+/// with previously selected boxes.  Bounding boxes with score less than
+/// `score_threshold` are removed.  Bounding boxes are supplied as
+/// [y1, x1, y2, x2], where (y1, x1) and (y2, x2) are the coordinates of any
+/// diagonal pair of box corners and the coordinates can be provided as normalized
+/// (i.e., lying in the interval [0, 1]) or absolute.  Note that this algorithm
+/// is agnostic to where the origin is in the coordinate system and more
+/// generally is invariant to orthogonal transformations and translations
+/// of the coordinate system; thus translating or reflections of the coordinate
+/// system result in the same boxes being selected by the algorithm.
+/// The output of this operation is a set of integers indexing into the input
+/// collection of bounding boxes representing the selected boxes.  The bounding
+/// box coordinates corresponding to the selected indices can then be obtained
+/// using the `tf.gather operation`.  For example:
+///   selected_indices = tf.image.non_max_suppression_v2(
+///       boxes, scores, max_output_size, iou_threshold, score_threshold)
+///   selected_boxes = tf.gather(boxes, selected_indices)
+///
+/// - Parameters:
+///     - boxes: A 2-D float tensor of shape `[num_boxes, 4]`.
+///     - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
+///         score corresponding to each box (each row of boxes).
+///     - max_output_size: A scalar integer tensor representing the maximum number of
+///         boxes to be selected by non max suppression.
+///     - iou_threshold: A 0-D float tensor representing the threshold for deciding whether
+///         boxes overlap too much with respect to IOU.
+///     - score_threshold: A 0-D float tensor representing the threshold for deciding when to remove
+///         boxes based on score.
+///
+/// - Attr pad_to_max_output_size: If true, the output `selected_indices` is padded to be of length
+///     `max_output_size`. Defaults to false.
+///
+/// - Outputs:
+///     - selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
+///         indices from the boxes tensor, where `M <= max_output_size`.
+///     - valid_outputs: A 0-D integer tensor representing the number of valid elements in
+///         `selected_indices`, with the valid elements appearing first.
+@inlinable @inline(__always)
+public static func nonMaxSuppressionV4<T: FloatingPoint & TensorFlowScalar>(
+    boxes: Tensor<T>,
+    scores: Tensor<T>,
+    maxOutputSize: Tensor<Int32>,
+    iouThreshold: Tensor<Float>,
+    scoreThreshold: Tensor<Float>,
+    padToMaxOutputSize: Bool = false
+) -> (selectedIndices: Tensor<Int32>, validOutputs: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("NonMaxSuppressionV4", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("pad_to_max_output_size", padToMaxOutputSize)
+    op.addInput(boxes)
+    op.addInput(scores)
+    op.addInput(maxOutputSize)
+    op.addInput(iouThreshold)
+    op.addInput(scoreThreshold)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Greedily selects a subset of bounding boxes in descending order of score,
+///
+/// pruning away boxes that have high overlaps
+/// with previously selected boxes.  Bounding boxes with score less than
+/// `score_threshold` are removed. N-by-n overlap values are supplied as square matrix,
+/// which allows for defining a custom overlap criterium (eg. intersection over union,
+/// intersection over area, etc.).
+///
+/// The output of this operation is a set of integers indexing into the input
+/// collection of bounding boxes representing the selected boxes.  The bounding
+/// box coordinates corresponding to the selected indices can then be obtained
+/// using the `tf.gather operation`.  For example:
+///
+///   selected_indices = tf.image.non_max_suppression_with_overlaps(
+///       overlaps, scores, max_output_size, overlap_threshold, score_threshold)
+///   selected_boxes = tf.gather(boxes, selected_indices)
+///
+/// - Parameters:
+///     - overlaps: A 2-D float tensor of shape `[num_boxes, num_boxes]` representing
+///         the n-by-n box overlap values.
+///     - scores: A 1-D float tensor of shape `[num_boxes]` representing a single
+///         score corresponding to each box (each row of boxes).
+///     - max_output_size: A scalar integer tensor representing the maximum number of
+///         boxes to be selected by non max suppression.
+///     - overlap_threshold: A 0-D float tensor representing the threshold for deciding whether
+///         boxes overlap too.
+///     - score_threshold: A 0-D float tensor representing the threshold for deciding when to remove
+///         boxes based on score.
+///
+/// - Output selected_indices: A 1-D integer tensor of shape `[M]` representing the selected
+///     indices from the boxes tensor, where `M <= max_output_size`.
+@inlinable @inline(__always)
+public static func nonMaxSuppressionWithOverlaps(
+    overlaps: Tensor<Float>,
+    scores: Tensor<Float>,
+    maxOutputSize: Tensor<Int32>,
+    overlapThreshold: Tensor<Float>,
+    scoreThreshold: Tensor<Float>
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("NonMaxSuppressionWithOverlaps", nOutputs)
+    op.addInput(overlaps)
+    op.addInput(scores)
+    op.addInput(maxOutputSize)
+    op.addInput(overlapThreshold)
+    op.addInput(scoreThreshold)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func none(
+) {
+  let nOutputs = 0
+    let op = makeOp("None", nOutputs)
+    
+    op.execute()
+}
+
+/// Returns the truth value of (x != y) element-wise.
+///
+/// *NOTE*: `NotEqual` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func notEqual<T: TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("NotEqual", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns the truth value of (x != y) element-wise.
+///
+/// *NOTE*: `NotEqual` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func notEqual(
+    _ x: StringTensor,
+    _ y: StringTensor
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("NotEqual", nOutputs)
+    op.updateAttribute("T", TensorDataType(TF_STRING))
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Finds values of the `n`-th order statistic for the last dimension.
+///
+/// If the input is a vector (rank-1), finds the entries which is the nth-smallest
+/// value in the vector and outputs their values as scalar tensor.
+///
+/// For matrices (resp. higher rank input), computes the entries which is the
+/// nth-smallest value in each row (resp. vector along the last dimension). Thus,
+///
+///     values.shape = input.shape[:-1]
+///
+/// - Parameters:
+///     - input: 1-D or higher with last dimension at least `n+1`.
+///     - n: 0-D. Position of sorted vector to select along the last dimension (along
+///         each row for matrices). Valid range of n is `[0, input.shape[:-1])`
+///
+/// - Attr reverse: When set to True, find the nth-largest value in the vector and vice
+///     versa.
+///
+/// - Output values: The `n`-th order statistic along each last dimensional slice.
+@inlinable @inline(__always)
+public static func nthElement<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    n: Tensor<Int32>,
+    reverse: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("NthElement", nOutputs)
+    op.updateAttribute("reverse", reverse)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(n)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func old(
+) {
+  let nOutputs = 0
+    let op = makeOp("Old", nOutputs)
+    
+    op.execute()
+}
+
+/// Returns a one-hot tensor.
+///
+/// The locations represented by indices in `indices` take value `on_value`,
+/// while all other locations take value `off_value`.
+///
+/// If the input `indices` is rank `N`, the output will have rank `N+1`,
+/// The new axis is created at dimension `axis` (default: the new axis is
+/// appended at the end).
+///
+/// If `indices` is a scalar the output shape will be a vector of length `depth`.
+///
+/// If `indices` is a vector of length `features`, the output shape will be:
+/// ```
+///   features x depth if axis == -1
+///   depth x features if axis == 0
+/// ```
+///
+/// If `indices` is a matrix (batch) with shape `[batch, features]`,
+/// the output shape will be:
+/// ```
+///   batch x features x depth if axis == -1
+///   batch x depth x features if axis == 1
+///   depth x batch x features if axis == 0
+/// ```
+///
+///
+/// Examples
+/// =========
+///
+/// Suppose that
+/// ```
+///   indices = [0, 2, -1, 1]
+///   depth = 3
+///   on_value = 5.0
+///   off_value = 0.0
+///   axis = -1
+/// ```
+///
+/// Then output is `[4 x 3]`:
+/// ```
+/// output =
+///   [5.0 0.0 0.0]  // one_hot(0)
+///   [0.0 0.0 5.0]  // one_hot(2)
+///   [0.0 0.0 0.0]  // one_hot(-1)
+///   [0.0 5.0 0.0]  // one_hot(1)
+/// ```
+///
+/// Suppose that
+/// ```
+///   indices = [0, 2, -1, 1]
+///   depth = 3
+///   on_value = 0.0
+///   off_value = 3.0
+///   axis = 0
+/// ```
+///
+/// Then output is `[3 x 4]`:
+/// ```
+/// output =
+///   [0.0 3.0 3.0 3.0]
+///   [3.0 3.0 3.0 0.0]
+///   [3.0 3.0 3.0 3.0]
+///   [3.0 0.0 3.0 3.0]
+/// //  ^                one_hot(0)
+/// //      ^            one_hot(2)
+/// //          ^        one_hot(-1)
+/// //              ^    one_hot(1)
+/// ```
+///
+/// Suppose that
+/// ```
+///   indices = [[0, 2], [1, -1]]
+///   depth = 3
+///   on_value = 1.0
+///   off_value = 0.0
+///   axis = -1
+/// ```
+///
+/// Then output is `[2 x 2 x 3]`:
+/// ```
+/// output =
+///   [
+///     [1.0, 0.0, 0.0]  // one_hot(0)
+///     [0.0, 0.0, 1.0]  // one_hot(2)
+///   ][
+///     [0.0, 1.0, 0.0]  // one_hot(1)
+///     [0.0, 0.0, 0.0]  // one_hot(-1)
+///   ]
+/// ```
+///
+/// - Parameters:
+///     - indices: A tensor of indices.
+///     - depth: A scalar defining the depth of the one hot dimension.
+///     - on_value: A scalar defining the value to fill in output when `indices[j] = i`.
+///     - off_value: A scalar defining the value to fill in output when `indices[j] != i`.
+///
+/// - Attr axis: The axis to fill (default: -1, a new inner-most axis).
+///
+/// - Output output: The one-hot tensor.
+@inlinable @inline(__always)
+public static func oneHot<
+    T: TensorFlowScalar,
+    Ti: BinaryInteger & TensorFlowScalar
+>(
+    indices: Tensor<Ti>,
+    depth: Tensor<Int32>,
+    onValue: Tensor<T>,
+    offValue: Tensor<T>,
+    axis: Int64 = -1
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("OneHot", nOutputs)
+    op.updateAttribute("axis", axis)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("TI", Ti.tensorFlowDataType)
+    op.addInput(indices)
+    op.addInput(depth)
+    op.addInput(onValue)
+    op.addInput(offValue)
+    return op.execute(Int(1))
+}
+
+/// Makes a "one-shot" iterator that can be iterated only once.
+///
+/// A one-shot iterator bundles the logic for defining the dataset and
+/// the state of the iterator in a single op, which allows simple input
+/// pipelines to be defined without an additional initialization
+/// ("MakeIterator") step.
+///
+/// One-shot iterators have the following limitations:
+///
+/// * They do not support parameterization: all logic for creating the underlying
+///   dataset must be bundled in the `dataset_factory` function.
+/// * They are not resettable. Once a one-shot iterator reaches the end of its
+///   underlying dataset, subsequent "IteratorGetNext" operations on that
+///   iterator will always produce an `OutOfRange` error.
+///
+/// For greater flexibility, use "Iterator" and "MakeIterator" to define
+/// an iterator using an arbitrary subgraph, which may capture tensors
+/// (including fed values) as parameters, and which may be reset multiple
+/// times by rerunning "MakeIterator".
+///
+/// - Attr dataset_factory: A function of type `() -> DT_VARIANT`, where the returned
+///     DT_VARIANT is a dataset.
+///
+/// - Output handle: A handle to the iterator that can be passed to an "IteratorGetNext"
+///     op.
+@inlinable @inline(__always)
+public static func oneShotIterator<DatasetfactoryIn: TensorGroup,
+    DatasetfactoryOut: TensorGroup>(
+    datasetFactory: (DatasetfactoryIn) -> DatasetfactoryOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?],
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("OneShotIterator", nOutputs)
+    op.updateAttribute("dataset_factory", datasetFactory)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Returns a tensor of ones with the same shape and type as x.
+///
+/// - Parameter x: a tensor of type T.
+///
+/// - Output y: a tensor of the same shape and type as x but filled with ones.
+@inlinable @inline(__always)
+public static func onesLike<T: TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("OnesLike", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func opWithDefaultAttr(
+    defaultFloat: Double = 123
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("OpWithDefaultAttr", nOutputs)
+    op.updateAttribute("default_float", defaultFloat)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func opWithFutureDefaultAttr(
+) {
+  let nOutputs = 0
+    let op = makeOp("OpWithFutureDefaultAttr", nOutputs)
+    
+    op.execute()
+}
+
+/// Creates a dataset by applying optimizations to `input_dataset`.
+///
+/// Creates a dataset by applying optimizations to `input_dataset`.
+///
+/// - Parameters:
+///     - input_dataset: A variant tensor representing the input dataset.
+///     - optimizations: A `tf.string` vector `tf.Tensor` identifying optimizations to use.
+@inlinable @inline(__always)
+public static func optimizeDataset(
+    inputDataset: VariantHandle,
+    optimizations: StringTensor,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?],
+    optimizationConfigs: [String]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("OptimizeDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("optimization_configs", optimizationConfigs)
+    op.addInput(inputDataset)
+    op.addInput(optimizations)
+    return op.execute(Int(1))
+}
+
+/// Constructs an Optional variant from a tuple of tensors.
+@inlinable @inline(__always)
+public static func optionalFromValue<ToutputTypes: TensorArrayProtocol>(
+    components: ToutputTypes
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("OptionalFromValue", nOutputs)
+    op.updateAttribute("Toutput_types", components._typeList)
+    op.addInputList(components)
+    return op.execute(Int(1))
+}
+
+/// Returns the value stored in an Optional variant or raises an error if none exists.
+@inlinable @inline(__always)
+public static func optionalGetValue<OutputTypes: TensorGroup>(
+    optional: VariantHandle,
+    outputShapes: [TensorShape?]
+) -> OutputTypes {
+  let nOutputs = Int(OutputTypes._typeList.count)
+    let op = makeOp("OptionalGetValue", nOutputs)
+    op.updateAttribute("output_types", OutputTypes._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(optional)
+    return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Returns true if and only if the given Optional variant has a value.
+@inlinable @inline(__always)
+public static func optionalHasValue(
+    optional: VariantHandle
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("OptionalHasValue", nOutputs)
+    op.addInput(optional)
+    return op.execute(Int(1))
+}
+
+/// Creates an Optional variant with no value.
+@inlinable @inline(__always)
+public static func optionalNone(
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("OptionalNone", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+/// Op removes all elements in the underlying container.
+@inlinable @inline(__always)
+public static func orderedMapClear(
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    dtypes: [TensorDataType],
+    container: String,
+    sharedName: String
+) {
+  let nOutputs = 0
+    let op = makeOp("OrderedMapClear", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", dtypes)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.execute()
+}
+
+/// Op returns the number of incomplete elements in the underlying container.
+@inlinable @inline(__always)
+public static func orderedMapIncompleteSize(
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    dtypes: [TensorDataType],
+    container: String,
+    sharedName: String
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("OrderedMapIncompleteSize", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", dtypes)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Op peeks at the values at the specified key.  If the
+///
+/// underlying container does not contain this key
+/// this op will block until it does.   This Op is optimized for
+/// performance.
+@inlinable @inline(__always)
+public static func orderedMapPeek<Dtypes: TensorGroup>(
+    key: Tensor<Int64>,
+    indices: Tensor<Int32>,
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    container: String,
+    sharedName: String
+) -> Dtypes {
+  let nOutputs = Int(Dtypes._typeList.count)
+    let op = makeOp("OrderedMapPeek", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", Dtypes._typeList)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(key)
+    op.addInput(indices)
+    return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// Op returns the number of elements in the underlying container.
+@inlinable @inline(__always)
+public static func orderedMapSize(
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    dtypes: [TensorDataType],
+    container: String,
+    sharedName: String
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("OrderedMapSize", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", dtypes)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Stage (key, values) in the underlying container which behaves like a ordered
+///
+/// associative container.   Elements are ordered by key.
+///
+/// - Parameters:
+///     - key: int64
+///     - values: a list of tensors
+///         dtypes A list of data types that inserted values should adhere to.
+///
+/// - Attrs:
+///     - capacity: Maximum number of elements in the Staging Area. If > 0, inserts
+///         on the container will block when the capacity is reached.
+///     - container: If non-empty, this queue is placed in the given container. Otherwise,
+///         a default container is used.
+///     - shared_name: It is necessary to match this name to the matching Unstage Op.
+@inlinable @inline(__always)
+public static func orderedMapStage<FakeDtypes: TensorArrayProtocol>(
+    key: Tensor<Int64>,
+    indices: Tensor<Int32>,
+    _ values: FakeDtypes,
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    dtypes: [TensorDataType],
+    container: String,
+    sharedName: String
+) {
+  let nOutputs = 0
+    let op = makeOp("OrderedMapStage", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", dtypes)
+    op.updateAttribute("fake_dtypes", values._typeList)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(key)
+    op.addInput(indices)
+    op.addInputList(values)
+    op.execute()
+}
+
+/// Op removes and returns the values associated with the key
+///
+/// from the underlying container.   If the underlying container
+/// does not contain this key, the op will block until it does.
+@inlinable @inline(__always)
+public static func orderedMapUnstage<Dtypes: TensorGroup>(
+    key: Tensor<Int64>,
+    indices: Tensor<Int32>,
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    container: String,
+    sharedName: String
+) -> Dtypes {
+  let nOutputs = Int(Dtypes._typeList.count)
+    let op = makeOp("OrderedMapUnstage", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", Dtypes._typeList)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(key)
+    op.addInput(indices)
+    return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// Op removes and returns the (key, value) element with the smallest
+///
+/// key from the underlying container.   If the underlying container
+/// does not contain elements, the op will block until it does.
+@inlinable @inline(__always)
+public static func orderedMapUnstageNoKey<Dtypes: TensorGroup>(
+    indices: Tensor<Int32>,
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    container: String,
+    sharedName: String
+) -> (key: Tensor<Int64>, values: Dtypes) {
+  let nOutputs = Int(1) + Int(Dtypes._typeList.count)
+    let op = makeOp("OrderedMapUnstageNoKey", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", Dtypes._typeList)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(indices)
+    return op.execute(Int(1), Int(Dtypes._typeList.count))
+}
+
+@inlinable @inline(__always)
+public static func outT<T: TensorFlowScalar>(
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("OutT", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func outTypeList<T: TensorGroup>(
+) -> T {
+  let nOutputs = Int(T._typeList.count)
+    let op = makeOp("OutTypeList", nOutputs)
+    op.updateAttribute("T", T._typeList)
+    return op.execute(Int(T._typeList.count))
+}
+
+@inlinable @inline(__always)
+public static func outTypeListRestrict<T: TensorGroup>(
+) -> T {
+  let nOutputs = Int(T._typeList.count)
+    let op = makeOp("OutTypeListRestrict", nOutputs)
+    op.updateAttribute("t", T._typeList)
+    return op.execute(Int(T._typeList.count))
+}
+
+/// Retrieves a single tensor from the computation outfeed.
+///
+/// This operation will block indefinitely until data is available.
+///
+/// - Attrs:
+///     - dtype: The type of elements in the tensor.
+///     - shape: The shape of the tensor.
+///     - device_ordinal: The TPU device to use. This should be -1 when the Op
+///         is running on a TPU device, and >= 0 when the Op is running on the CPU
+///         device.
+///
+/// - Output output: A tensor that will be read from the device outfeed.
+@inlinable @inline(__always)
+public static func outfeedDequeue<Dtype: TensorFlowScalar>(
+    shape: TensorShape?,
+    deviceOrdinal: Int64 = -1
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("OutfeedDequeue", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape", shape)
+    op.updateAttribute("device_ordinal", deviceOrdinal)
+    return op.execute(Int(1))
+}
+
+/// Retrieve multiple values from the computation outfeed.
+///
+/// This operation will block indefinitely until data is available. Output `i`
+/// corresponds to XLA tuple element `i`.
+///
+/// - Attrs:
+///     - dtypes: The element types of each element in `outputs`.
+///     - shapes: The shapes of each tensor in `outputs`.
+///     - device_ordinal: The TPU device to use. This should be -1 when the Op
+///         is running on a TPU device, and >= 0 when the Op is running on the CPU
+///         device.
+///
+/// - Output outputs: A list of tensors that will be read from the outfeed.
+@inlinable @inline(__always)
+public static func outfeedDequeueTuple<Dtypes: TensorGroup>(
+    shapes: [TensorShape?],
+    deviceOrdinal: Int64 = -1
+) -> Dtypes {
+  let nOutputs = Int(Dtypes._typeList.count)
+    let op = makeOp("OutfeedDequeueTuple", nOutputs)
+    op.updateAttribute("dtypes", Dtypes._typeList)
+    op.updateAttribute("shapes", shapes)
+    op.updateAttribute("device_ordinal", deviceOrdinal)
+    return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// Enqueue a Tensor on the computation outfeed.
+///
+/// - Parameter input: A tensor that will be inserted into the outfeed queue.
+@inlinable @inline(__always)
+public static func outfeedEnqueue<Dtype: TensorFlowScalar>(
+    _ input: Tensor<Dtype>
+) {
+  let nOutputs = 0
+    let op = makeOp("OutfeedEnqueue", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(input)
+    op.execute()
+}
+
+/// Enqueue multiple Tensor values on the computation outfeed.
+///
+/// - Parameter inputs: A list of tensors that will be inserted into the outfeed queue as an
+///     XLA tuple.
+@inlinable @inline(__always)
+public static func outfeedEnqueueTuple<Dtypes: TensorArrayProtocol>(
+    inputs: Dtypes
+) {
+  let nOutputs = 0
+    let op = makeOp("OutfeedEnqueueTuple", nOutputs)
+    op.updateAttribute("dtypes", inputs._typeList)
+    op.addInputList(inputs)
+    op.execute()
+}
+
+/// Packs a list of `N` rank-`R` tensors into one rank-`(R+1)` tensor.
+///
+/// Packs the `N` tensors in `values` into a tensor with rank one higher than each
+/// tensor in `values`, by packing them along the `axis` dimension.
+/// Given a list of tensors of shape `(A, B, C)`;
+///
+/// if `axis == 0` then the `output` tensor will have the shape `(N, A, B, C)`.
+/// if `axis == 1` then the `output` tensor will have the shape `(A, N, B, C)`.
+/// Etc.
+///
+/// For example:
+///
+/// ```
+/// # 'x' is [1, 4]
+/// # 'y' is [2, 5]
+/// # 'z' is [3, 6]
+/// pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
+/// pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]]
+/// ```
+///
+/// This is the opposite of `unpack`.
+///
+/// - Parameter values: Must be of same shape and type.
+///
+/// - Attr axis: Dimension along which to pack.  Negative values wrap around, so the
+///     valid range is `[-(R+1), R+1)`.
+///
+/// - Output output: The packed tensor.
+@inlinable @inline(__always)
+public static func pack<T: TensorFlowScalar>(
+    _ values: [Tensor<T>],
+    axis: Int64 = 0
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Pack", nOutputs)
+    op.updateAttribute("N", values.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("axis", axis)
+    op.addInputList(values)
+    return op.execute(Int(1))
+}
+
+/// Pads a tensor with zeros.
+///
+/// This operation pads a `input` with zeros according to the `paddings` you
+/// specify. `paddings` is an integer tensor with shape `[Dn, 2]`, where n is the
+/// rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
+/// how many zeros to add before the contents of `input` in that dimension, and
+/// `paddings[D, 1]` indicates how many zeros to add after the contents of `input`
+/// in that dimension.
+///
+/// The padded size of each dimension D of the output is:
+///
+/// `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[1, 1], [2, 2]]
+/// # 'paddings' is [[1, 1], [2, 2]]
+/// # rank of 't' is 2
+/// pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
+///                       [0, 0, 1, 1, 0, 0]
+///                       [0, 0, 2, 2, 0, 0]
+///                       [0, 0, 0, 0, 0, 0]]
+/// ```
+///
+@inlinable @inline(__always)
+public static func pad<
+    T: TensorFlowScalar,
+    Tpaddings: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    paddings: Tensor<Tpaddings>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Pad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tpaddings", Tpaddings.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(paddings)
+    return op.execute(Int(1))
+}
+
+/// Pads a tensor.
+///
+/// This operation pads `input` according to the `paddings` and `constant_values`
+/// you specify. `paddings` is an integer tensor with shape `[Dn, 2]`, where n is
+/// the rank of `input`. For each dimension D of `input`, `paddings[D, 0]` indicates
+/// how many padding values to add before the contents of `input` in that dimension,
+/// and `paddings[D, 1]` indicates how many padding values to add after the contents
+/// of `input` in that dimension. `constant_values` is a scalar tensor of the same
+/// type as `input` that indicates the value to use for padding `input`.
+///
+/// The padded size of each dimension D of the output is:
+///
+/// `paddings(D, 0) + input.dim_size(D) + paddings(D, 1)`
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[1, 1], [2, 2]]
+/// # 'paddings' is [[1, 1], [2, 2]]
+/// # 'constant_values' is 0
+/// # rank of 't' is 2
+/// pad(t, paddings) ==> [[0, 0, 0, 0, 0, 0]
+///                       [0, 0, 1, 1, 0, 0]
+///                       [0, 0, 2, 2, 0, 0]
+///                       [0, 0, 0, 0, 0, 0]]
+/// ```
+@inlinable @inline(__always)
+public static func padV2<
+    T: TensorFlowScalar,
+    Tpaddings: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    paddings: Tensor<Tpaddings>,
+    constantValues: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("PadV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tpaddings", Tpaddings.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(paddings)
+    op.addInput(constantValues)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that batches and pads `batch_size` elements from the input.
+///
+/// - Parameters:
+///     - batch_size: A scalar representing the number of elements to accumulate in a
+///         batch.
+///     - padded_shapes: A list of int64 tensors representing the desired padded shapes
+///         of the corresponding output components. These shapes may be partially
+///         specified, using `-1` to indicate that a particular dimension should be
+///         padded to the maximum size of all batch elements.
+///     - padding_values: A list of scalars containing the padding value to use for
+///         each of the outputs.
+@inlinable @inline(__always)
+public static func paddedBatchDataset<ToutputTypes: TensorArrayProtocol>(
+    inputDataset: VariantHandle,
+    batchSize: Tensor<Int64>,
+    paddedShapes: [Tensor<Int64>],
+    paddingValues: ToutputTypes,
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("PaddedBatchDataset", nOutputs)
+    op.updateAttribute("Toutput_types", paddingValues._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("N", paddedShapes.count)
+    op.addInput(inputDataset)
+    op.addInput(batchSize)
+    op.addInputList(paddedShapes)
+    op.addInputList(paddingValues)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that batches and pads `batch_size` elements from the input.
+///
+/// - Parameters:
+///     - batch_size: A scalar representing the number of elements to accumulate in a
+///         batch.
+///     - padded_shapes: A list of int64 tensors representing the desired padded shapes
+///         of the corresponding output components. These shapes may be partially
+///         specified, using `-1` to indicate that a particular dimension should be
+///         padded to the maximum size of all batch elements.
+///     - padding_values: A list of scalars containing the padding value to use for
+///         each of the outputs.
+///     - drop_remainder: A scalar representing whether the last batch should be dropped in case its size
+///         is smaller than desired.
+@inlinable @inline(__always)
+public static func paddedBatchDatasetV2<ToutputTypes: TensorArrayProtocol>(
+    inputDataset: VariantHandle,
+    batchSize: Tensor<Int64>,
+    paddedShapes: [Tensor<Int64>],
+    paddingValues: ToutputTypes,
+    dropRemainder: Tensor<Bool>,
+    parallelCopy: Bool = false,
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("PaddedBatchDatasetV2", nOutputs)
+    op.updateAttribute("parallel_copy", parallelCopy)
+    op.updateAttribute("Toutput_types", paddingValues._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("N", paddedShapes.count)
+    op.addInput(inputDataset)
+    op.addInput(batchSize)
+    op.addInputList(paddedShapes)
+    op.addInputList(paddingValues)
+    op.addInput(dropRemainder)
+    return op.execute(Int(1))
+}
+
+/// A queue that produces elements in first-in first-out order.
+///
+/// Variable-size shapes are allowed by setting the corresponding shape dimensions
+/// to 0 in the shape attr.  In this case DequeueMany will pad up to the maximum
+/// size of any given element in the minibatch.  See below for details.
+///
+/// - Attrs:
+///     - component_types: The type of each component in a value.
+///     - shapes: The shape of each component in a value. The length of this attr must
+///         be either 0 or the same as the length of component_types.
+///         Shapes of fixed rank but variable size are allowed by setting
+///         any shape dimension to -1.  In this case, the inputs' shape may vary along
+///         the given dimension, and DequeueMany will pad the given dimension with
+///         zeros up to the maximum shape of all elements in the given batch.
+///         If the length of this attr is 0, different queue elements may have
+///         different ranks and shapes, but only one element may be dequeued at a time.
+///     - capacity: The upper bound on the number of elements in this queue.
+///         Negative numbers mean no limit.
+///     - container: If non-empty, this queue is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this queue will be shared under the given name
+///         across multiple sessions.
+///
+/// - Output handle: The handle to the queue.
+@inlinable @inline(__always)
+public static func paddingFIFOQueueV2(
+    componentTypes: [TensorDataType],
+    shapes: [TensorShape?],
+    capacity: Int64 = -1,
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("PaddingFIFOQueueV2", nOutputs)
+    op.updateAttribute("component_types", componentTypes)
+    op.updateAttribute("shapes", shapes)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Concatenates a list of `N` tensors along the first dimension.
+///
+/// The input tensors are all required to have size 1 in the first dimension.
+///
+/// For example:
+///
+/// ```
+/// # 'x' is [[1, 4]]
+/// # 'y' is [[2, 5]]
+/// # 'z' is [[3, 6]]
+/// parallel_concat([x, y, z]) => [[1, 4], [2, 5], [3, 6]]  # Pack along first dim.
+/// ```
+///
+/// The difference between concat and parallel_concat is that concat requires all
+/// of the inputs be computed before the operation will begin but doesn't require
+/// that the input shapes be known during graph construction.  Parallel concat
+/// will copy pieces of the input into the output as they become available, in
+/// some situations this can provide a performance benefit.
+///
+/// - Parameter values: Tensors to be concatenated. All must have size 1 in the first dimension
+///     and same shape.
+///
+/// - Attr shape: the final shape of the result; should be equal to the shapes of any input
+///     but with the number of input values in the first dimension.
+///
+/// - Output output: The concatenated tensor.
+@inlinable @inline(__always)
+public static func parallelConcat<T: TensorFlowScalar>(
+    _ values: [Tensor<T>],
+    shape: TensorShape?
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ParallelConcat", nOutputs)
+    op.updateAttribute("N", values.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("shape", shape)
+    op.addInputList(values)
+    return op.execute(Int(1))
+}
+
+/// Interleave the values from the `data` tensors into a single tensor.
+///
+/// Builds a merged tensor such that
+///
+/// ```python
+///     merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
+/// ```
+///
+/// For example, if each `indices[m]` is scalar or vector, we have
+///
+/// ```python
+///     # Scalar indices:
+///     merged[indices[m], ...] = data[m][...]
+///
+///     # Vector indices:
+///     merged[indices[m][i], ...] = data[m][i, ...]
+/// ```
+///
+/// Each `data[i].shape` must start with the corresponding `indices[i].shape`,
+/// and the rest of `data[i].shape` must be constant w.r.t. `i`.  That is, we
+/// must have `data[i].shape = indices[i].shape + constant`.  In terms of this
+/// `constant`, the output shape is
+///
+///     merged.shape = [max(indices)] + constant
+///
+/// Values may be merged in parallel, so if an index appears in both `indices[m][i]`
+/// and `indices[n][j]`, the result may be invalid. This differs from the normal
+/// DynamicStitch operator that defines the behavior in that case.
+///
+/// For example:
+///
+/// ```python
+///     indices[0] = 6
+///     indices[1] = [4, 1]
+///     indices[2] = [[5, 2], [0, 3]]
+///     data[0] = [61, 62]
+///     data[1] = [[41, 42], [11, 12]]
+///     data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
+///     merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
+///               [51, 52], [61, 62]]
+/// ```
+///
+/// This method can be used to merge partitions created by `dynamic_partition`
+/// as illustrated on the following example:
+///
+/// ```python
+///     # Apply function (increments x_i) on elements for which a certain condition
+///     # apply (x_i != -1 in this example).
+///     x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
+///     condition_mask=tf.not_equal(x,tf.constant(-1.))
+///     partitioned_data = tf.dynamic_partition(
+///         x, tf.cast(condition_mask, tf.int32) , 2)
+///     partitioned_data[1] = partitioned_data[1] + 1.0
+///     condition_indices = tf.dynamic_partition(
+///         tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
+///     x = tf.dynamic_stitch(condition_indices, partitioned_data)
+///     # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
+///     # unchanged.
+/// ```
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/DynamicStitch.png" alt>
+/// </div>
+@inlinable @inline(__always)
+public static func parallelDynamicStitch<T: TensorFlowScalar>(
+    indices: [Tensor<Int32>],
+    data: [Tensor<T>]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ParallelDynamicStitch", nOutputs)
+    op.updateAttribute("N", indices.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInputList(indices)
+    op.addInputList(data)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+///
+/// - Attr f: A function mapping elements of `input_dataset`, concatenated with
+///     `other_arguments`, to a Dataset variant that contains elements matching
+///     `output_types` and `output_shapes`.
+@inlinable @inline(__always)
+public static func parallelInterleaveDatasetV2<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    otherArguments: Targuments,
+    cycleLength: Tensor<Int64>,
+    blockLength: Tensor<Int64>,
+    numParallelCalls: Tensor<Int64>,
+    f: (FIn) -> FOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?],
+    sloppy: Bool = false
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ParallelInterleaveDatasetV2", nOutputs)
+    op.updateAttribute("f", f)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("sloppy", sloppy)
+    op.addInput(inputDataset)
+    op.addInputList(otherArguments)
+    op.addInput(cycleLength)
+    op.addInput(blockLength)
+    op.addInput(numParallelCalls)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
+///
+/// Unlike a "MapDataset", which applies `f` sequentially, this dataset invokes up
+/// to `num_parallel_calls` copies of `f` in parallel.
+///
+/// - Parameter num_parallel_calls: The number of concurrent invocations of `f` that process
+///     elements from `input_dataset` in parallel.
+@inlinable @inline(__always)
+public static func parallelMapDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Targuments: TensorArrayProtocol
+>(
+    inputDataset: VariantHandle,
+    otherArguments: Targuments,
+    numParallelCalls: Tensor<Int32>,
+    f: (FIn) -> FOut,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?],
+    useInterOpParallelism: Bool = true,
+    sloppy: Bool = false,
+    preserveCardinality: Bool = false
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ParallelMapDataset", nOutputs)
+    op.updateAttribute("f", f)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("use_inter_op_parallelism", useInterOpParallelism)
+    op.updateAttribute("sloppy", sloppy)
+    op.updateAttribute("preserve_cardinality", preserveCardinality)
+    op.addInput(inputDataset)
+    op.addInputList(otherArguments)
+    op.addInput(numParallelCalls)
+    return op.execute(Int(1))
+}
+
+/// Outputs random values from a normal distribution. The parameters may each be a
+///
+/// scalar which applies to the entire output, or a vector of length shape[0] which
+/// stores the parameters for each batch.
+///
+/// - Parameters:
+///     - shape: The shape of the output tensor. Batches are indexed by the 0th dimension.
+///     - means: The mean parameter of each batch.
+///     - stdevs: The standard deviation parameter of each batch. Must be greater than 0.
+///     - minvals: The minimum cutoff. May be -infinity.
+///     - maxvals: The maximum cutoff. May be +infinity, and must be more than the minval
+///         for each batch.
+///
+/// - Attrs:
+///     - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: A second seed to avoid seed collision.
+///     - dtype: The type of the output.
+///
+/// - Output output: A matrix of shape num_batches x samples_per_batch, filled with random
+///     truncated normal values using the parameters for each row.
+@inlinable @inline(__always)
+public static func parameterizedTruncatedNormal<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar
+>(
+    shape: Tensor<T>,
+    means: Tensor<Dtype>,
+    stdevs: Tensor<Dtype>,
+    minvals: Tensor<Dtype>,
+    maxvals: Tensor<Dtype>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("ParameterizedTruncatedNormal", nOutputs)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(shape)
+    op.addInput(means)
+    op.addInput(stdevs)
+    op.addInput(minvals)
+    op.addInput(maxvals)
+    return op.execute(Int(1))
+}
+
+/// Transforms a vector of brain.Example protos (as strings) into typed tensors.
+///
+/// - Parameters:
+///     - serialized: A vector containing a batch of binary serialized Example protos.
+///     - names: A vector containing the names of the serialized protos.
+///         May contain, for example, table key (descriptive) names for the
+///         corresponding serialized protos.  These are purely useful for debugging
+///         purposes, and the presence of values here has no effect on the output.
+///         May also be an empty vector if no names are available.
+///         If non-empty, this vector must be the same length as "serialized".
+///     - sparse_keys: A list of Nsparse string Tensors (scalars).
+///         The keys expected in the Examples' features associated with sparse values.
+///     - dense_keys: A list of Ndense string Tensors (scalars).
+///         The keys expected in the Examples' features associated with dense values.
+///     - dense_defaults: A list of Ndense Tensors (some may be empty).
+///         dense_defaults[j] provides default values
+///         when the example's feature_map lacks dense_key[j].  If an empty Tensor is
+///         provided for dense_defaults[j], then the Feature dense_keys[j] is required.
+///         The input type is inferred from dense_defaults[j], even when it's empty.
+///         If dense_defaults[j] is not empty, and dense_shapes[j] is fully defined,
+///         then the shape of dense_defaults[j] must match that of dense_shapes[j].
+///         If dense_shapes[j] has an undefined major dimension (variable strides dense
+///         feature), dense_defaults[j] must contain a single element:
+///         the padding element.
+///
+/// - Attrs:
+///     - sparse_types: A list of Nsparse types; the data types of data in each Feature
+///         given in sparse_keys.
+///         Currently the ParseExample supports DT_FLOAT (FloatList),
+///         DT_INT64 (Int64List), and DT_STRING (BytesList).
+///     - dense_shapes: A list of Ndense shapes; the shapes of data in each Feature
+///         given in dense_keys.
+///         The number of elements in the Feature corresponding to dense_key[j]
+///         must always equal dense_shapes[j].NumEntries().
+///         If dense_shapes[j] == (D0, D1, ..., DN) then the shape of output
+///         Tensor dense_values[j] will be (|serialized|, D0, D1, ..., DN):
+///         The dense outputs are just the inputs row-stacked by batch.
+///         This works for dense_shapes[j] = (-1, D1, ..., DN).  In this case
+///         the shape of the output Tensor dense_values[j] will be
+///         (|serialized|, M, D1, .., DN), where M is the maximum number of blocks
+///         of elements of length D1 * .... * DN, across all minibatch entries
+///         in the input.  Any minibatch entry with less than M blocks of elements of
+///         length D1 * ... * DN will be padded with the corresponding default_value
+///         scalar element along the second dimension.
+@inlinable @inline(__always)
+public static func parseExample<
+    SparseTypes: TensorGroup,
+    Tdense: TensorArrayProtocol
+>(
+    serialized: StringTensor,
+    names: StringTensor,
+    sparseKeys: [StringTensor],
+    denseKeys: [StringTensor],
+    denseDefaults: Tdense,
+    denseShapes: [TensorShape?]
+) -> (sparseIndices: [Tensor<Int64>], sparseValues: SparseTypes, sparseShapes: [Tensor<Int64>], denseValues: Tdense) {
+  let nOutputs = Int(sparseKeys.count) + Int(SparseTypes._typeList.count) + Int(sparseKeys.count) + Int(denseDefaults._typeList.count)
+    let op = makeOp("ParseExample", nOutputs)
+    op.updateAttribute("Nsparse", sparseKeys.count)
+    op.updateAttribute("Ndense", denseKeys.count)
+    op.updateAttribute("sparse_types", SparseTypes._typeList)
+    op.updateAttribute("Tdense", denseDefaults._typeList)
+    op.updateAttribute("dense_shapes", denseShapes)
+    op.addInput(serialized)
+    op.addInput(names)
+    op.addInputList(sparseKeys)
+    op.addInputList(denseKeys)
+    op.addInputList(denseDefaults)
+    return op.execute(Int(sparseKeys.count), Int(SparseTypes._typeList.count), Int(sparseKeys.count), Int(denseDefaults._typeList.count))
+}
+
+/// Transforms a vector of brain.SequenceExample protos (as strings) into typed tensors.
+///
+/// - Parameters:
+///     - serialized: A vector containing binary serialized SequenceExample protos.
+///     - debug_name: A vector containing the names of the serialized protos.
+///         May contain, for example, table key (descriptive) name for the
+///         corresponding serialized proto.  This is purely useful for debugging
+///         purposes, and the presence of values here has no effect on the output.
+///         May also be an empty vector if no name is available.
+///     - context_dense_defaults: A list of Ncontext_dense Tensors (some may be empty).
+///         context_dense_defaults[j] provides default values
+///         when the SequenceExample's context map lacks context_dense_key[j].
+///         If an empty Tensor is provided for context_dense_defaults[j],
+///         then the Feature context_dense_keys[j] is required.
+///         The input type is inferred from context_dense_defaults[j], even when it's
+///         empty.  If context_dense_defaults[j] is not empty, its shape must match
+///         context_dense_shapes[j].
+///
+/// - Attrs:
+///     - feature_list_dense_missing_assumed_empty: A vector listing the
+///         FeatureList keys which may be missing from the SequenceExamples.  If the
+///         associated FeatureList is missing, it is treated as empty.  By default,
+///         any FeatureList not listed in this vector must exist in the SequenceExamples.
+///     - context_sparse_keys: A list of Ncontext_sparse string Tensors (scalars).
+///         The keys expected in the Examples' features associated with context_sparse
+///         values.
+///     - context_dense_keys: A list of Ncontext_dense string Tensors (scalars).
+///         The keys expected in the SequenceExamples' context features associated with
+///         dense values.
+///     - feature_list_sparse_keys: A list of Nfeature_list_sparse string Tensors
+///         (scalars).  The keys expected in the FeatureLists associated with sparse
+///         values.
+///     - feature_list_dense_keys: A list of Nfeature_list_dense string Tensors (scalars).
+///         The keys expected in the SequenceExamples' feature_lists associated
+///         with lists of dense values.
+///     - context_sparse_types: A list of Ncontext_sparse types; the data types of data in
+///         each context Feature given in context_sparse_keys.
+///         Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
+///         DT_INT64 (Int64List), and DT_STRING (BytesList).
+///     - context_dense_shapes: A list of Ncontext_dense shapes; the shapes of data in
+///         each context Feature given in context_dense_keys.
+///         The number of elements in the Feature corresponding to context_dense_key[j]
+///         must always equal context_dense_shapes[j].NumEntries().
+///         The shape of context_dense_values[j] will match context_dense_shapes[j].
+///     - feature_list_sparse_types: A list of Nfeature_list_sparse types; the data types
+///         of data in each FeatureList given in feature_list_sparse_keys.
+///         Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
+///         DT_INT64 (Int64List), and DT_STRING (BytesList).
+///     - feature_list_dense_shapes: A list of Nfeature_list_dense shapes; the shapes of
+///         data in each FeatureList given in feature_list_dense_keys.
+///         The shape of each Feature in the FeatureList corresponding to
+///         feature_list_dense_key[j] must always equal
+///         feature_list_dense_shapes[j].NumEntries().
+@inlinable @inline(__always)
+public static func parseSequenceExample<
+    ContextSparseTypes: TensorGroup,
+    TcontextDense: TensorArrayProtocol,
+    FeatureListDenseTypes: TensorGroup,
+    FeatureListSparseTypes: TensorGroup
+>(
+    serialized: StringTensor,
+    debugName: StringTensor,
+    contextDenseDefaults: TcontextDense,
+    featureListDenseMissingAssumedEmpty: [String],
+    contextSparseKeys: [String],
+    contextDenseKeys: [String],
+    featureListSparseKeys: [String],
+    featureListDenseKeys: [String],
+    ncontextSparse: Int64 = 0,
+    ncontextDense: Int64 = 0,
+    nfeatureListSparse: Int64 = 0,
+    nfeatureListDense: Int64 = 0,
+    contextDenseShapes: [TensorShape?],
+    featureListDenseShapes: [TensorShape?]
+) -> (contextSparseIndices: [Tensor<Int64>], contextSparseValues: ContextSparseTypes, contextSparseShapes: [Tensor<Int64>], contextDenseValues: TcontextDense, featureListSparseIndices: [Tensor<Int64>], featureListSparseValues: FeatureListSparseTypes, featureListSparseShapes: [Tensor<Int64>], featureListDenseValues: FeatureListDenseTypes, featureListDenseLengths: [Tensor<Int64>]) {
+  let nOutputs = Int(ncontextSparse) + Int(ContextSparseTypes._typeList.count) + Int(ncontextSparse) + Int(contextDenseDefaults._typeList.count) + Int(nfeatureListSparse) + Int(FeatureListSparseTypes._typeList.count) + Int(nfeatureListSparse) + Int(FeatureListDenseTypes._typeList.count) + Int(nfeatureListDense)
+    let op = makeOp("ParseSequenceExample", nOutputs)
+    op.updateAttribute("feature_list_dense_missing_assumed_empty", featureListDenseMissingAssumedEmpty)
+    op.updateAttribute("context_sparse_keys", contextSparseKeys)
+    op.updateAttribute("context_dense_keys", contextDenseKeys)
+    op.updateAttribute("feature_list_sparse_keys", featureListSparseKeys)
+    op.updateAttribute("feature_list_dense_keys", featureListDenseKeys)
+    op.updateAttribute("Ncontext_sparse", ncontextSparse)
+    op.updateAttribute("Ncontext_dense", ncontextDense)
+    op.updateAttribute("Nfeature_list_sparse", nfeatureListSparse)
+    op.updateAttribute("Nfeature_list_dense", nfeatureListDense)
+    op.updateAttribute("context_sparse_types", ContextSparseTypes._typeList)
+    op.updateAttribute("Tcontext_dense", contextDenseDefaults._typeList)
+    op.updateAttribute("feature_list_dense_types", FeatureListDenseTypes._typeList)
+    op.updateAttribute("context_dense_shapes", contextDenseShapes)
+    op.updateAttribute("feature_list_sparse_types", FeatureListSparseTypes._typeList)
+    op.updateAttribute("feature_list_dense_shapes", featureListDenseShapes)
+    op.addInput(serialized)
+    op.addInput(debugName)
+    op.addInputList(contextDenseDefaults)
+    return op.execute(Int(ncontextSparse), Int(ContextSparseTypes._typeList.count), Int(ncontextSparse), Int(contextDenseDefaults._typeList.count), Int(nfeatureListSparse), Int(FeatureListSparseTypes._typeList.count), Int(nfeatureListSparse), Int(FeatureListDenseTypes._typeList.count), Int(nfeatureListDense))
+}
+
+/// Transforms a tf.Example proto (as a string) into typed tensors.
+///
+/// - Parameters:
+///     - serialized: A vector containing a batch of binary serialized Example protos.
+///     - dense_defaults: A list of Tensors (some may be empty), whose length matches
+///         the length of `dense_keys`. dense_defaults[j] provides default values
+///         when the example's feature_map lacks dense_key[j].  If an empty Tensor is
+///         provided for dense_defaults[j], then the Feature dense_keys[j] is required.
+///         The input type is inferred from dense_defaults[j], even when it's empty.
+///         If dense_defaults[j] is not empty, and dense_shapes[j] is fully defined,
+///         then the shape of dense_defaults[j] must match that of dense_shapes[j].
+///         If dense_shapes[j] has an undefined major dimension (variable strides dense
+///         feature), dense_defaults[j] must contain a single element:
+///         the padding element.
+///
+/// - Attrs:
+///     - num_sparse: The number of sparse features to be parsed from the example. This
+///         must match the lengths of `sparse_keys` and `sparse_types`.
+///     - sparse_keys: A list of `num_sparse` strings.
+///         The keys expected in the Examples' features associated with sparse values.
+///     - dense_keys: The keys expected in the Examples' features associated with dense
+///         values.
+///     - sparse_types: A list of `num_sparse` types; the data types of data in each
+///         Feature given in sparse_keys.
+///         Currently the ParseSingleExample op supports DT_FLOAT (FloatList),
+///         DT_INT64 (Int64List), and DT_STRING (BytesList).
+///     - Tdense: The data types of data in each Feature given in dense_keys.
+///         The length of this list must match the length of `dense_keys`.
+///         Currently the ParseSingleExample op supports DT_FLOAT (FloatList),
+///         DT_INT64 (Int64List), and DT_STRING (BytesList).
+///     - dense_shapes: The shapes of data in each Feature given in dense_keys.
+///         The length of this list must match the length of `dense_keys`.  The
+///         number of elements in the Feature corresponding to dense_key[j] must
+///         always equal dense_shapes[j].NumEntries().  If dense_shapes[j] ==
+///         (D0, D1, ..., DN) then the shape of output Tensor dense_values[j]
+///         will be (D0, D1, ..., DN): In the case dense_shapes[j] = (-1, D1,
+///         ..., DN), the shape of the output Tensor dense_values[j] will be (M,
+///         D1, .., DN), where M is the number of blocks of elements of length
+///         D1 * .... * DN, in the input.
+@inlinable @inline(__always)
+public static func parseSingleExample<
+    SparseTypes: TensorGroup,
+    Tdense: TensorArrayProtocol
+>(
+    serialized: StringTensor,
+    denseDefaults: Tdense,
+    numSparse: Int64,
+    sparseKeys: [String],
+    denseKeys: [String],
+    denseShapes: [TensorShape?]
+) -> (sparseIndices: [Tensor<Int64>], sparseValues: SparseTypes, sparseShapes: [Tensor<Int64>], denseValues: Tdense) {
+  let nOutputs = Int(numSparse) + Int(SparseTypes._typeList.count) + Int(numSparse) + Int(denseDefaults._typeList.count)
+    let op = makeOp("ParseSingleExample", nOutputs)
+    op.updateAttribute("num_sparse", numSparse)
+    op.updateAttribute("sparse_keys", sparseKeys)
+    op.updateAttribute("dense_keys", denseKeys)
+    op.updateAttribute("sparse_types", SparseTypes._typeList)
+    op.updateAttribute("Tdense", denseDefaults._typeList)
+    op.updateAttribute("dense_shapes", denseShapes)
+    op.addInput(serialized)
+    op.addInputList(denseDefaults)
+    return op.execute(Int(numSparse), Int(SparseTypes._typeList.count), Int(numSparse), Int(denseDefaults._typeList.count))
+}
+
+/// Transforms a scalar brain.SequenceExample proto (as strings) into typed tensors.
+///
+/// - Parameters:
+///     - serialized: A scalar containing a binary serialized SequenceExample proto.
+///     - feature_list_dense_missing_assumed_empty: A vector listing the
+///         FeatureList keys which may be missing from the SequenceExample.  If the
+///         associated FeatureList is missing, it is treated as empty.  By default,
+///         any FeatureList not listed in this vector must exist in the SequenceExample.
+///     - context_sparse_keys: A list of Ncontext_sparse string Tensors (scalars).
+///         The keys expected in the Examples' features associated with context_sparse
+///         values.
+///     - context_dense_keys: A list of Ncontext_dense string Tensors (scalars).
+///         The keys expected in the SequenceExamples' context features associated with
+///         dense values.
+///     - feature_list_sparse_keys: A list of Nfeature_list_sparse string Tensors
+///         (scalars).  The keys expected in the FeatureLists associated with sparse
+///         values.
+///     - feature_list_dense_keys: A list of Nfeature_list_dense string Tensors (scalars).
+///         The keys expected in the SequenceExamples' feature_lists associated
+///         with lists of dense values.
+///     - context_dense_defaults: A list of Ncontext_dense Tensors (some may be empty).
+///         context_dense_defaults[j] provides default values
+///         when the SequenceExample's context map lacks context_dense_key[j].
+///         If an empty Tensor is provided for context_dense_defaults[j],
+///         then the Feature context_dense_keys[j] is required.
+///         The input type is inferred from context_dense_defaults[j], even when it's
+///         empty.  If context_dense_defaults[j] is not empty, its shape must match
+///         context_dense_shapes[j].
+///     - debug_name: A scalar containing the name of the serialized proto.
+///         May contain, for example, table key (descriptive) name for the
+///         corresponding serialized proto.  This is purely useful for debugging
+///         purposes, and the presence of values here has no effect on the output.
+///         May also be an empty scalar if no name is available.
+///
+/// - Attrs:
+///     - context_sparse_types: A list of Ncontext_sparse types; the data types of data in
+///         each context Feature given in context_sparse_keys.
+///         Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
+///         DT_INT64 (Int64List), and DT_STRING (BytesList).
+///     - context_dense_shapes: A list of Ncontext_dense shapes; the shapes of data in
+///         each context Feature given in context_dense_keys.
+///         The number of elements in the Feature corresponding to context_dense_key[j]
+///         must always equal context_dense_shapes[j].NumEntries().
+///         The shape of context_dense_values[j] will match context_dense_shapes[j].
+///     - feature_list_sparse_types: A list of Nfeature_list_sparse types; the data types
+///         of data in each FeatureList given in feature_list_sparse_keys.
+///         Currently the ParseSingleSequenceExample supports DT_FLOAT (FloatList),
+///         DT_INT64 (Int64List), and DT_STRING (BytesList).
+///     - feature_list_dense_shapes: A list of Nfeature_list_dense shapes; the shapes of
+///         data in each FeatureList given in feature_list_dense_keys.
+///         The shape of each Feature in the FeatureList corresponding to
+///         feature_list_dense_key[j] must always equal
+///         feature_list_dense_shapes[j].NumEntries().
+@inlinable @inline(__always)
+public static func parseSingleSequenceExample<
+    ContextSparseTypes: TensorGroup,
+    TcontextDense: TensorArrayProtocol,
+    FeatureListDenseTypes: TensorGroup,
+    FeatureListSparseTypes: TensorGroup
+>(
+    serialized: StringTensor,
+    featureListDenseMissingAssumedEmpty: StringTensor,
+    contextSparseKeys: [StringTensor],
+    contextDenseKeys: [StringTensor],
+    featureListSparseKeys: [StringTensor],
+    featureListDenseKeys: [StringTensor],
+    contextDenseDefaults: TcontextDense,
+    debugName: StringTensor,
+    contextDenseShapes: [TensorShape?],
+    featureListDenseShapes: [TensorShape?]
+) -> (contextSparseIndices: [Tensor<Int64>], contextSparseValues: ContextSparseTypes, contextSparseShapes: [Tensor<Int64>], contextDenseValues: TcontextDense, featureListSparseIndices: [Tensor<Int64>], featureListSparseValues: FeatureListSparseTypes, featureListSparseShapes: [Tensor<Int64>], featureListDenseValues: FeatureListDenseTypes) {
+  let nOutputs = Int(contextSparseKeys.count) + Int(ContextSparseTypes._typeList.count) + Int(contextSparseKeys.count) + Int(contextDenseDefaults._typeList.count) + Int(featureListSparseKeys.count) + Int(FeatureListSparseTypes._typeList.count) + Int(featureListSparseKeys.count) + Int(FeatureListDenseTypes._typeList.count)
+    let op = makeOp("ParseSingleSequenceExample", nOutputs)
+    op.updateAttribute("Ncontext_sparse", contextSparseKeys.count)
+    op.updateAttribute("Ncontext_dense", contextDenseKeys.count)
+    op.updateAttribute("Nfeature_list_sparse", featureListSparseKeys.count)
+    op.updateAttribute("Nfeature_list_dense", featureListDenseKeys.count)
+    op.updateAttribute("context_sparse_types", ContextSparseTypes._typeList)
+    op.updateAttribute("Tcontext_dense", contextDenseDefaults._typeList)
+    op.updateAttribute("feature_list_dense_types", FeatureListDenseTypes._typeList)
+    op.updateAttribute("context_dense_shapes", contextDenseShapes)
+    op.updateAttribute("feature_list_sparse_types", FeatureListSparseTypes._typeList)
+    op.updateAttribute("feature_list_dense_shapes", featureListDenseShapes)
+    op.addInput(serialized)
+    op.addInput(featureListDenseMissingAssumedEmpty)
+    op.addInputList(contextSparseKeys)
+    op.addInputList(contextDenseKeys)
+    op.addInputList(featureListSparseKeys)
+    op.addInputList(featureListDenseKeys)
+    op.addInputList(contextDenseDefaults)
+    op.addInput(debugName)
+    return op.execute(Int(contextSparseKeys.count), Int(ContextSparseTypes._typeList.count), Int(contextSparseKeys.count), Int(contextDenseDefaults._typeList.count), Int(featureListSparseKeys.count), Int(FeatureListSparseTypes._typeList.count), Int(featureListSparseKeys.count), Int(FeatureListDenseTypes._typeList.count))
+}
+
+/// Transforms a serialized tensorflow.TensorProto proto into a Tensor.
+///
+/// - Parameter serialized: A scalar string containing a serialized TensorProto proto.
+///
+/// - Attr out_type: The type of the serialized tensor.  The provided type must match the
+///     type of the serialized tensor and no implicit conversion will take place.
+///
+/// - Output output: A Tensor of type `out_type`.
+@inlinable @inline(__always)
+public static func parseTensor<OutType: TensorFlowScalar>(
+    serialized: StringTensor
+) -> Tensor<OutType> {
+  let nOutputs = Int(1)
+    let op = makeOp("ParseTensor", nOutputs)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(serialized)
+    return op.execute(Int(1))
+}
+
+/// returns `f(inputs)`, where `f`'s body is placed and partitioned.
+///
+/// - Parameter args: A list of input tensors.
+///
+/// - Attrs:
+///     - Tin: A list of input types.
+///     - Tout: A list of output types.
+///     - f:       A function that takes 'args', a list of tensors, and returns 'output',
+///               another list of tensors. Input and output types are specified by 'Tin'
+///               and 'Tout'. The function body of f will be placed and partitioned across
+///               devices, setting this op apart from the regular Call op.
+///
+/// - Output output: A list of return values.
+@inlinable @inline(__always)
+public static func partitionedCall<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    FIn: TensorGroup,
+    FOut: TensorGroup
+>(
+    args: Tin,
+    f: (FIn) -> FOut,
+    config: String,
+    configProto: String,
+    executorType: String
+) -> Tout {
+  let nOutputs = Int(Tout._typeList.count)
+    let op = makeOp("PartitionedCall", nOutputs)
+    op.updateAttribute("Tin", args._typeList)
+    op.updateAttribute("Tout", Tout._typeList)
+    op.updateAttribute("f", f)
+    op.updateAttribute("config", config)
+    op.updateAttribute("config_proto", configProto)
+    op.updateAttribute("executor_type", executorType)
+    op.addInputList(args)
+    return op.execute(Int(Tout._typeList.count))
+}
+
+/// A placeholder op for a value that will be fed into the computation.
+///
+/// N.B. This operation will fail with an error if it is executed. It is
+/// intended as a way to represent a value that will always be fed, and to
+/// provide attrs that enable the fed value to be checked at runtime.
+///
+/// - Attrs:
+///     - dtype: The type of elements in the tensor.
+///     - shape: (Optional) The shape of the tensor. If the shape has 0 dimensions, the
+///         shape is unconstrained.
+///
+/// - Output output: A placeholder tensor that must be replaced using the feed mechanism.
+@inlinable @inline(__always)
+public static func placeholder<Dtype: TensorFlowScalar>(
+    shape: TensorShape?
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("Placeholder", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape", shape)
+    return op.execute(Int(1))
+}
+
+/// A placeholder op for a value that will be fed into the computation.
+///
+/// N.B. This operation will fail with an error if it is executed. It is
+/// intended as a way to represent a value that will always be fed, and to
+/// provide attrs that enable the fed value to be checked at runtime.
+///
+/// - Attrs:
+///     - dtype: The type of elements in the tensor.
+///     - shape: The shape of the tensor. The shape can be any partially-specified
+///         shape.  To be unconstrained, pass in a shape with unknown rank.
+///
+/// - Output output: A placeholder tensor that must be replaced using the feed mechanism.
+@inlinable @inline(__always)
+public static func placeholderV2<Dtype: TensorFlowScalar>(
+    shape: TensorShape?
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("PlaceholderV2", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape", shape)
+    return op.execute(Int(1))
+}
+
+/// A placeholder op that passes through `input` when its output is not fed.
+///
+/// - Parameter input: The default value to produce when `output` is not fed.
+///
+/// - Attrs:
+///     - dtype: The type of elements in the tensor.
+///     - shape: The (possibly partial) shape of the tensor.
+///
+/// - Output output: A placeholder tensor that defaults to `input` if it is not fed.
+@inlinable @inline(__always)
+public static func placeholderWithDefault<Dtype: TensorFlowScalar>(
+    _ input: Tensor<Dtype>,
+    shape: TensorShape?
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("PlaceholderWithDefault", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape", shape)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Compute the polygamma function \\(\psi^{(n)}(x)\\).
+///
+/// The polygamma function is defined as:
+///
+///
+/// \\(\psi^{(a)}(x) = \frac{d^a}{dx^a} \psi(x)\\)
+///
+/// where \\(\psi(x)\\) is the digamma function.
+/// The polygamma function is defined only for non-negative integer orders \\a\\.
+@inlinable @inline(__always)
+public static func polygamma<T: FloatingPoint & TensorFlowScalar>(
+    _ a: Tensor<T>,
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Polygamma", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func polymorphic<T: TensorFlowScalar>(
+    _ a: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Polymorphic", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func polymorphicDefaultOut<T: TensorFlowScalar>(
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("PolymorphicDefaultOut", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func polymorphicOut<T: TensorFlowScalar>(
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("PolymorphicOut", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    return op.execute(Int(1))
+}
+
+/// Computes element-wise population count (a.k.a. popcount, bitsum, bitcount).
+///
+/// For each entry in `x`, calculates the number of `1` (on) bits in the binary
+/// representation of that entry.
+///
+/// **NOTE**: It is more efficient to first `tf.bitcast` your tensors into
+/// `int32` or `int64` and perform the bitcount on the result, than to feed in
+/// 8- or 16-bit inputs and then aggregate the resulting counts.
+@inlinable @inline(__always)
+public static func populationCount<T: BinaryInteger & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<UInt8> {
+  let nOutputs = Int(1)
+    let op = makeOp("PopulationCount", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the power of one value to another.
+///
+/// Given a tensor `x` and a tensor `y`, this operation computes \\(x^y\\) for
+/// corresponding elements in `x` and `y`. For example:
+///
+/// ```
+/// # tensor 'x' is [[2, 2]], [3, 3]]
+/// # tensor 'y' is [[8, 16], [2, 3]]
+/// tf.pow(x, y) ==> [[256, 65536], [9, 27]]
+/// ```
+@inlinable @inline(__always)
+public static func pow<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Pow", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that asynchronously prefetches elements from `input_dataset`.
+///
+/// - Parameter buffer_size: The maximum number of elements to buffer in an iterator over
+///     this dataset.
+@inlinable @inline(__always)
+public static func prefetchDataset(
+    inputDataset: VariantHandle,
+    bufferSize: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("PrefetchDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(bufferSize)
+    return op.execute(Int(1))
+}
+
+/// An op which linearizes one Tensor value to an opaque variant tensor.
+///
+/// - Parameter input: A tensor that will be linearized.
+///
+/// - Attrs:
+///     - dtype: The type of elements in the tensor.
+///     - shape: The shape of the tensor.
+///     - layout: A vector holding the requested layout in minor-to-major sequence. If a layout
+///         attribute is passed but its values are all -1 the layout will be computed by
+///         the infeed operation.
+@inlinable @inline(__always)
+public static func prelinearize<Dtype: TensorFlowScalar>(
+    _ input: Tensor<Dtype>,
+    shape: TensorShape?,
+    layout: [Int32]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("Prelinearize", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape", shape)
+    op.updateAttribute("layout", layout)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// An op which linearizes multiple Tensor values to an opaque variant tensor.
+///
+/// - Parameter inputs: A list of tensors that will be provided using the infeed mechanism.
+///
+/// - Attrs:
+///     - dtypes: The element types of each element in `inputs`.
+///     - shapes: The shapes of each tensor in `inputs`.
+///     - layouts: A vector holding the requested layout in minor-to-major sequence for all the
+///         tuple shapes in the order the shapes appear in the "shapes" input. The layout
+///         elements for a sub-shape can be set to -1 in which case the corresponding layout
+///         will be computed by the infeed operation.
+@inlinable @inline(__always)
+public static func prelinearizeTuple<Dtypes: TensorArrayProtocol>(
+    inputs: Dtypes,
+    shapes: [TensorShape?],
+    layouts: [Int32]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("PrelinearizeTuple", nOutputs)
+    op.updateAttribute("dtypes", inputs._typeList)
+    op.updateAttribute("shapes", shapes)
+    op.updateAttribute("layouts", layouts)
+    op.addInputList(inputs)
+    return op.execute(Int(1))
+}
+
+/// 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.
+///
+/// - Parameter input: any tensor.
+///
+/// - Attr message: Will be printed in the error when anyone tries to differentiate
+///     this operation.
+///
+/// - Output output: the same input tensor.
+@inlinable @inline(__always)
+public static func preventGradient<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    message: String
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("PreventGradient", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("message", message)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Prints a list of tensors.
+///
+/// Passes `input` through to `output` and prints `data` when evaluating.
+///
+/// - Parameters:
+///     - input: The tensor passed to `output`
+///     - data: A list of tensors to print out when op is evaluated.
+///
+/// - Attrs:
+///     - message: A string, prefix of the error message.
+///     - first_n: Only log `first_n` number of times. -1 disables logging.
+///     - summarize: Only print this many entries of each tensor.
+///
+/// - Output output: = The unmodified `input` tensor
+@inlinable @inline(__always)
+public static func print<
+    T: TensorFlowScalar,
+    U: TensorArrayProtocol
+>(
+    _ input: Tensor<T>,
+    data: U,
+    message: String,
+    firstN: Int64 = -1,
+    summarize: Int64 = 3
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Print", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("U", data._typeList)
+    op.updateAttribute("message", message)
+    op.updateAttribute("first_n", firstN)
+    op.updateAttribute("summarize", summarize)
+    op.addInput(input)
+    op.addInputList(data)
+    return op.execute(Int(1))
+}
+
+/// Prints a string scalar.
+///
+/// Prints a string scalar to the desired output_stream.
+///
+/// - Parameter input: The string scalar to print.
+///
+/// - Attr output_stream: A string specifying the output stream or logging level to print to.
+@inlinable @inline(__always)
+public static func printV2(
+    _ input: StringTensor,
+    outputStream: String = "stderr"
+) {
+  let nOutputs = 0
+    let op = makeOp("PrintV2", nOutputs)
+    op.updateAttribute("output_stream", outputStream)
+    op.addInput(input)
+    op.execute()
+}
+
+/// A queue that produces elements sorted by the first component value.
+///
+/// Note that the PriorityQueue requires the first component of any element
+/// to be a scalar int64, in addition to the other elements declared by
+/// component_types.  Therefore calls to Enqueue and EnqueueMany (resp. Dequeue
+/// and DequeueMany) on a PriorityQueue will all require (resp. output) one extra
+/// entry in their input (resp. output) lists.
+///
+/// - Attrs:
+///     - component_types: The type of each component in a value.
+///     - shapes: The shape of each component in a value. The length of this attr must
+///         be either 0 or the same as the length of component_types. If the length of
+///         this attr is 0, the shapes of queue elements are not constrained, and
+///         only one element may be dequeued at a time.
+///     - capacity: The upper bound on the number of elements in this queue.
+///         Negative numbers mean no limit.
+///     - container: If non-empty, this queue is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this queue will be shared under the given name
+///         across multiple sessions.
+///
+/// - Output handle: The handle to the queue.
+@inlinable @inline(__always)
+public static func priorityQueueV2(
+    componentTypes: [TensorDataType],
+    shapes: [TensorShape?],
+    capacity: Int64 = -1,
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("PriorityQueueV2", nOutputs)
+    op.updateAttribute("component_types", componentTypes)
+    op.updateAttribute("shapes", shapes)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Computes the product of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///     - input: The tensor to reduce.
+///     - reduction_indices: The dimensions to reduce. Must be in the range
+///         `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func prod<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    reductionIndices: Tensor<Tidx>,
+    keepDims: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Prod", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(reductionIndices)
+    return op.execute(Int(1))
+}
+
+/// Invokes a python function to compute func(input)->output.
+///
+/// This operation is considered stateful. For a stateless version, see
+/// PyFuncStateless.
+///
+/// - Parameter input: List of Tensors that will provide input to the Op.
+///
+/// - Attrs:
+///     - token: A token representing a registered python function in this address space.
+///     - Tin: Data types of the inputs to the op.
+///     - Tout: Data types of the outputs from the op.
+///         The length of the list specifies the number of outputs.
+///
+/// - Output output: The outputs from the Op.
+@inlinable @inline(__always)
+public static func pyFunc<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup
+>(
+    _ input: Tin,
+    token: String
+) -> Tout {
+  let nOutputs = Int(Tout._typeList.count)
+    let op = makeOp("PyFunc", nOutputs)
+    op.updateAttribute("token", token)
+    op.updateAttribute("Tin", input._typeList)
+    op.updateAttribute("Tout", Tout._typeList)
+    op.addInputList(input)
+    return op.execute(Int(Tout._typeList.count))
+}
+
+/// A stateless version of PyFunc.
+@inlinable @inline(__always)
+public static func pyFuncStateless<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup
+>(
+    _ input: Tin,
+    token: String
+) -> Tout {
+  let nOutputs = Int(Tout._typeList.count)
+    let op = makeOp("PyFuncStateless", nOutputs)
+    op.updateAttribute("token", token)
+    op.updateAttribute("Tin", input._typeList)
+    op.updateAttribute("Tout", Tout._typeList)
+    op.addInputList(input)
+    return op.execute(Int(Tout._typeList.count))
+}
+
+/// Computes the QR decompositions of one or more matrices.
+///
+/// Computes the QR decomposition of each inner matrix in `tensor` such that
+/// `tensor[..., :, :] = q[..., :, :] * r[..., :,:])`
+///
+/// ```python
+/// # a is a tensor.
+/// # q is a tensor of orthonormal matrices.
+/// # r is a tensor of upper triangular matrices.
+/// q, r = qr(a)
+/// q_full, r_full = qr(a, full_matrices=True)
+/// ```
+///
+/// - Parameter input: A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
+///     form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
+///
+/// - Attr full_matrices: If true, compute full-sized `q` and `r`. If false
+///     (the default), compute only the leading `P` columns of `q`.
+///
+/// - Outputs:
+///     - q: Orthonormal basis for range of `a`. If `full_matrices` is `False` then
+///         shape is `[..., M, P]`; if `full_matrices` is `True` then shape is
+///         `[..., M, M]`.
+///     - r: Triangular factor. If `full_matrices` is `False` then shape is
+///         `[..., P, N]`. If `full_matrices` is `True` then shape is `[..., M, N]`.
+@inlinable @inline(__always)
+public static func qr<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    fullMatrices: Bool = false
+) -> (q: Tensor<T>, r: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("Qr", nOutputs)
+    op.updateAttribute("full_matrices", fullMatrices)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Use QuantizeAndDequantizeV2 instead.
+@inlinable @inline(__always)
+public static func quantizeAndDequantize<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    signedInput: Bool = true,
+    numBits: Int64 = 8,
+    rangeGiven: Bool = false,
+    inputMin: Double = 0,
+    inputMax: Double = 0
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("QuantizeAndDequantize", nOutputs)
+    op.updateAttribute("signed_input", signedInput)
+    op.updateAttribute("num_bits", numBits)
+    op.updateAttribute("range_given", rangeGiven)
+    op.updateAttribute("input_min", inputMin)
+    op.updateAttribute("input_max", inputMax)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Quantizes then dequantizes a tensor.
+///
+/// This op simulates the precision loss from the quantized forward pass by:
+///
+/// 1. Quantizing the tensor to fixed point numbers, which should match the target
+///    quantization method when it is used in inference.
+/// 2. Dequantizing it back to floating point numbers for the following ops, most
+///    likely matmul.
+///
+/// There are different ways to quantize. This version uses only scaling, so 0.0
+/// maps to 0.
+///
+/// From the specified 'num_bits' in the quantized output type, it determines
+/// minimum and maximum representable quantized values.
+///
+/// e.g.
+///
+/// *   [-128, 127] for signed, num_bits = 8, or
+/// *   [0, 255] for unsigned, num_bits = 8.
+///
+/// If range_given == False, the initial input_min, input_max will be determined
+/// automatically as the minimum and maximum values in the input tensor, otherwise
+/// the specified values of input_min, input_max are used.
+///
+/// Note: If the input_min, input_max are specified, they do not need to equal the
+/// actual minimum and maximum values in the tensor. e.g. in some cases it may be
+/// beneficial to specify these values such that the low probability extremes of the
+/// input distribution are clipped.
+///
+/// This op determines the maximum scale_factor that would map the initial
+/// [input_min, input_max] range to a range that lies within the representable
+/// quantized range.
+///
+/// It determines the scale from one of input_min and input_max, then updates the
+/// other one to maximize the respresentable range.
+///
+/// e.g.
+///
+/// *   if the output is signed, num_bits = 8, [input_min, input_max] = [-10.0,
+///     5.0]: it would use a scale_factor of -128 / -10.0 = 12.8 In this case, it
+///     would update input_max to be 127 / 12.8 = 9.921875
+/// *   if the output is signed, num_bits = 8, [input_min, input_max] = [-10.0,
+///     10.0]: it would use a scale_factor of 127 / 10.0 = 12.7 In this case, it
+///     would update input_min to be 128.0 / 12.7 = -10.07874
+/// *   if the output is unsigned, input_min is forced to be 0, and only the
+///     specified input_max is used.
+///
+/// After determining the scale_factor and updating the input range, it applies the
+/// following to each value in the 'input' tensor.
+///
+/// output = round(clamp(value, input_min, input_max) * scale_factor) / scale_factor.
+///
+/// The above round function rounds the value based on the given round_mode.
+///
+///
+/// - Parameters:
+///     - input: Tensor to quantize and then dequantize.
+///     - input_min: If `range_given == True`, this specifies the minimum input value that needs to
+///         be represented, otherwise it is determined from the min value of the `input`
+///         tensor.
+///     - input_max: If `range_given == True`, this specifies the maximum input value that needs to
+///         be represented, otherwise it is determined from the max value of the `input`
+///         tensor.
+///
+/// - Attrs:
+///     - signed_input: Whether the quantization is signed or unsigned. (actually this parameter should
+///         have been called <b>`signed_output`</b>)
+///     - num_bits: The bitwidth of the quantization.
+///     - range_given: Whether the range is given or should be determined from the `input` tensor.
+///     - round_mode: The 'round_mode' attribute controls which rounding tie-breaking algorithm is
+///         used when rounding float values to their quantized equivalents. The following
+///         rounding modes are currently supported:
+///
+///         *   HALF_TO_EVEN: this is the default round_mode.
+///         *   HALF_UP: round towards positive. In this mode 7.5 rounds up to 8 and -7.5
+///             rounds up to -7.
+///
+@inlinable @inline(__always)
+public static func quantizeAndDequantizeV2<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    inputMin: Tensor<T>,
+    inputMax: Tensor<T>,
+    signedInput: Bool = true,
+    numBits: Int64 = 8,
+    rangeGiven: Bool = false,
+    roundMode: RoundMode = .halfToEven
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("QuantizeAndDequantizeV2", nOutputs)
+    op.updateAttribute("signed_input", signedInput)
+    op.updateAttribute("num_bits", numBits)
+    op.updateAttribute("range_given", rangeGiven)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("round_mode", roundMode.cName)
+    op.addInput(input)
+    op.addInput(inputMin)
+    op.addInput(inputMax)
+    return op.execute(Int(1))
+}
+
+/// Quantizes then dequantizes a tensor.
+///
+/// This is almost identical to QuantizeAndDequantizeV2, except that num_bits is a
+/// tensor, so its value can change during training.
+@inlinable @inline(__always)
+public static func quantizeAndDequantizeV3<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    inputMin: Tensor<T>,
+    inputMax: Tensor<T>,
+    numBits: Tensor<Int32>,
+    signedInput: Bool = true,
+    rangeGiven: Bool = true
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("QuantizeAndDequantizeV3", nOutputs)
+    op.updateAttribute("signed_input", signedInput)
+    op.updateAttribute("range_given", rangeGiven)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(inputMin)
+    op.addInput(inputMax)
+    op.addInput(numBits)
+    return op.execute(Int(1))
+}
+
+/// Convert the quantized 'input' tensor into a lower-precision 'output', using the
+///
+/// actual distribution of the values to maximize the usage of the lower bit depth
+/// and adjusting the output min and max ranges accordingly.
+///
+/// [input_min, input_max] are scalar floats that specify the range for the float
+/// interpretation of the 'input' data. For example, if input_min is -1.0f and
+/// input_max is 1.0f, and we are dealing with quint16 quantized data, then a 0
+/// value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.
+///
+/// This operator tries to squeeze as much precision as possible into an output with
+/// a lower bit depth by calculating the actual min and max values found in the
+/// data. For example, maybe that quint16 input has no values lower than 16,384 and
+/// none higher than 49,152. That means only half the range is actually needed, all
+/// the float interpretations are between -0.5f and 0.5f, so if we want to compress
+/// the data into a quint8 output, we can use that range rather than the theoretical
+/// -1.0f to 1.0f that is suggested by the input min and max.
+///
+/// In practice, this is most useful for taking output from operations like
+/// QuantizedMatMul that can produce higher bit-depth outputs than their inputs and
+/// may have large potential output ranges, but in practice have a distribution of
+/// input values that only uses a small fraction of the possible range. By feeding
+/// that output into this operator, we can reduce it from 32 bits down to 8 with
+/// minimal loss of accuracy.
+///
+/// - Parameters:
+///     - input_min: The float value that the minimum quantized input value represents.
+///     - input_max: The float value that the maximum quantized input value represents.
+///
+/// - Attrs:
+///     - Tinput: The type of the input.
+///     - out_type: The type of the output. Should be a lower bit depth than Tinput.
+///
+/// - Outputs:
+///     - output_min: The float value that the minimum quantized output value represents.
+///     - output_max: The float value that the maximum quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizeDownAndShrinkRange<
+    Tinput: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    inputMin: Tensor<Float>,
+    inputMax: Tensor<Float>
+) -> (output: Tensor<OutType>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizeDownAndShrinkRange", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(inputMin)
+    op.addInput(inputMax)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Quantize the 'input' tensor of type float to 'output' tensor of type 'T'.
+///
+/// [min_range, max_range] are scalar floats that specify the range for
+/// the 'input' data. The 'mode' attribute controls exactly which calculations are
+/// used to convert the float values to their quantized equivalents.  The
+/// 'round_mode' attribute controls which rounding tie-breaking algorithm is used
+/// when rounding float values to their quantized equivalents.
+///
+/// In 'MIN_COMBINED' mode, each value of the tensor will undergo the following:
+///
+/// ```
+/// out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
+/// if T == qint8: out[i] -= (range(T) + 1) / 2.0
+/// ```
+///
+/// here `range(T) = numeric_limits<T>::max() - numeric_limits<T>::min()`
+///
+/// *MIN_COMBINED Mode Example*
+///
+/// Assume the input is type float and has a possible range of [0.0, 6.0] and the
+/// output type is quint8 ([0, 255]). The min_range and max_range values should be
+/// specified as 0.0 and 6.0. Quantizing from float to quint8 will multiply each
+/// value of the input by 255/6 and cast to quint8.
+///
+/// If the output type was qint8 ([-128, 127]), the operation will additionally
+/// subtract each value by 128 prior to casting, so that the range of values aligns
+/// with the range of qint8.
+///
+/// If the mode is 'MIN_FIRST', then this approach is used:
+///
+/// ```
+/// num_discrete_values = 1 << (# of bits in T)
+/// range_adjust = num_discrete_values / (num_discrete_values - 1)
+/// range = (range_max - range_min) * range_adjust
+/// range_scale = num_discrete_values / range
+/// quantized = round(input * range_scale) - round(range_min * range_scale) +
+///   numeric_limits<T>::min()
+/// quantized = max(quantized, numeric_limits<T>::min())
+/// quantized = min(quantized, numeric_limits<T>::max())
+/// ```
+///
+/// The biggest difference between this and MIN_COMBINED is that the minimum range
+/// is rounded first, before it's subtracted from the rounded value. With
+/// MIN_COMBINED, a small bias is introduced where repeated iterations of quantizing
+/// and dequantizing will introduce a larger and larger error.
+///
+/// *SCALED mode Example*
+///
+/// `SCALED` mode matches the quantization approach used in
+/// `QuantizeAndDequantize{V2|V3}`.
+///
+/// If the mode is `SCALED`, we do not use the full range of the output type,
+/// choosing to elide the lowest possible value for symmetry (e.g., output range is
+/// -127 to 127, not -128 to 127 for signed 8 bit quantization), so that 0.0 maps to
+/// 0.
+///
+/// We first find the range of values in our tensor. The
+/// range we use is always centered on 0, so we find m such that
+///
+/// ```c++
+///   m = max(abs(input_min), abs(input_max))
+/// ```
+///
+/// Our input tensor range is then `[-m, m]`.
+///
+/// Next, we choose our fixed-point quantization buckets, `[min_fixed, max_fixed]`.
+/// If T is signed, this is
+///
+/// ```
+///   num_bits = sizeof(T) * 8
+///   [min_fixed, max_fixed] =
+///       [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]
+/// ```
+///
+/// Otherwise, if T is unsigned, the fixed-point range is
+///
+/// ```
+///   [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]
+/// ```
+///
+/// From this we compute our scaling factor, s:
+///
+/// ```c++
+///   s = (max_fixed - min_fixed) / (2 * m)
+/// ```
+///
+/// Now we can quantize the elements of our tensor:
+///
+/// ```c++
+/// result = round(input * s)
+/// ```
+///
+/// One thing to watch out for is that the operator may choose to adjust the
+/// requested minimum and maximum values slightly during the quantization process,
+/// so you should always use the output ports as the range for further calculations.
+/// For example, if the requested minimum and maximum values are close to equal,
+/// they will be separated by a small epsilon value to prevent ill-formed quantized
+/// buffers from being created. Otherwise, you can end up with buffers where all the
+/// quantized values map to the same float value, which causes problems for
+/// operations that have to perform further calculations on them.
+///
+/// - Parameters:
+///     - min_range: The minimum scalar value possibly produced for the input.
+///     - max_range: The maximum scalar value possibly produced for the input.
+///
+/// - Outputs:
+///     - output: The quantized data produced from the float input.
+///     - output_min: The actual minimum scalar value used for the output.
+///     - output_max: The actual maximum scalar value used for the output.
+@inlinable @inline(__always)
+public static func quantizeV2<T: TensorFlowScalar>(
+    _ input: Tensor<Float>,
+    minRange: Tensor<Float>,
+    maxRange: Tensor<Float>,
+    mode: Mode = .minCombined,
+    roundMode: RoundMode6 = .halfAwayFromZero
+) -> (output: Tensor<T>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizeV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("mode", mode.cName)
+    op.updateAttribute("round_mode", roundMode.cName)
+    op.addInput(input)
+    op.addInput(minRange)
+    op.addInput(maxRange)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Returns x + y element-wise, working on quantized buffers.
+///
+/// - Parameters:
+///     - min_x: The float value that the lowest quantized `x` value represents.
+///     - max_x: The float value that the highest quantized `x` value represents.
+///     - min_y: The float value that the lowest quantized `y` value represents.
+///     - max_y: The float value that the highest quantized `y` value represents.
+///
+/// - Outputs:
+///     - min_z: The float value that the lowest quantized output value represents.
+///     - max_z: The float value that the highest quantized output value represents.
+///
+///         *NOTE*: `QuantizedAdd` supports limited forms of broadcasting. More about
+///         broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func quantizedAdd<
+    T1: TensorFlowScalar,
+    T2: TensorFlowScalar,
+    Toutput: TensorFlowScalar
+>(
+    _ x: Tensor<T1>,
+    _ y: Tensor<T2>,
+    minX: Tensor<Float>,
+    maxX: Tensor<Float>,
+    minY: Tensor<Float>,
+    maxY: Tensor<Float>
+) -> (z: Tensor<Toutput>, minZ: Tensor<Float>, maxZ: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedAdd", nOutputs)
+    op.updateAttribute("T1", T1.tensorFlowDataType)
+    op.updateAttribute("T2", T2.tensorFlowDataType)
+    op.updateAttribute("Toutput", Toutput.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    op.addInput(minX)
+    op.addInput(maxX)
+    op.addInput(minY)
+    op.addInput(maxY)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Produces the average pool of the input tensor for quantized types.
+///
+/// - Parameters:
+///     - input: 4-D with shape `[batch, height, width, channels]`.
+///     - min_input: The float value that the lowest quantized input value represents.
+///     - max_input: The float value that the highest quantized input value represents.
+///
+/// - Attrs:
+///     - ksize: The size of the window for each dimension of the input tensor.
+///         The length must be 4 to match the number of dimensions of the input.
+///     - strides: The stride of the sliding window for each dimension of the input
+///         tensor.  The length must be 4 to match the number of dimensions of the input.
+///     - padding: The type of padding algorithm to use.
+///
+/// - Outputs:
+///     - min_output: The float value that the lowest quantized output value represents.
+///     - max_output: The float value that the highest quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizedAvgPool<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding
+) -> (output: Tensor<T>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedAvgPool", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.addInput(input)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Quantized Batch normalization.
+///
+/// This op is deprecated and will be removed in the future. Prefer
+/// `tf.nn.batch_normalization`.
+///
+/// - Parameters:
+///     - t: A 4D input Tensor.
+///     - t_min: The value represented by the lowest quantized input.
+///     - t_max: The value represented by the highest quantized input.
+///     - m: A 1D mean Tensor with size matching the last dimension of t.
+///         This is the first output from tf.nn.moments,
+///         or a saved moving average thereof.
+///     - m_min: The value represented by the lowest quantized mean.
+///     - m_max: The value represented by the highest quantized mean.
+///     - v: A 1D variance Tensor with size matching the last dimension of t.
+///         This is the second output from tf.nn.moments,
+///         or a saved moving average thereof.
+///     - v_min: The value represented by the lowest quantized variance.
+///     - v_max: The value represented by the highest quantized variance.
+///     - beta: A 1D beta Tensor with size matching the last dimension of t.
+///         An offset to be added to the normalized tensor.
+///     - beta_min: The value represented by the lowest quantized offset.
+///     - beta_max: The value represented by the highest quantized offset.
+///     - gamma: A 1D gamma Tensor with size matching the last dimension of t.
+///         If "scale_after_normalization" is true, this tensor will be multiplied
+///         with the normalized tensor.
+///     - gamma_min: The value represented by the lowest quantized gamma.
+///     - gamma_max: The value represented by the highest quantized gamma.
+///
+/// - Attrs:
+///     - variance_epsilon: A small float number to avoid dividing by 0.
+///     - scale_after_normalization: A bool indicating whether the resulted tensor
+///         needs to be multiplied with gamma.
+@inlinable @inline(__always)
+public static func quantizedBatchNormWithGlobalNormalization<
+    Tinput: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    t: Tensor<Tinput>,
+    tMin: Tensor<Float>,
+    tMax: Tensor<Float>,
+    m: Tensor<Tinput>,
+    mMin: Tensor<Float>,
+    mMax: Tensor<Float>,
+    v: Tensor<Tinput>,
+    vMin: Tensor<Float>,
+    vMax: Tensor<Float>,
+    beta: Tensor<Tinput>,
+    betaMin: Tensor<Float>,
+    betaMax: Tensor<Float>,
+    gamma: Tensor<Tinput>,
+    gammaMin: Tensor<Float>,
+    gammaMax: Tensor<Float>,
+    varianceEpsilon: Double,
+    scaleAfterNormalization: Bool
+) -> (result: Tensor<OutType>, resultMin: Tensor<Float>, resultMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedBatchNormWithGlobalNormalization", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("variance_epsilon", varianceEpsilon)
+    op.updateAttribute("scale_after_normalization", scaleAfterNormalization)
+    op.addInput(t)
+    op.addInput(tMin)
+    op.addInput(tMax)
+    op.addInput(m)
+    op.addInput(mMin)
+    op.addInput(mMax)
+    op.addInput(v)
+    op.addInput(vMin)
+    op.addInput(vMax)
+    op.addInput(beta)
+    op.addInput(betaMin)
+    op.addInput(betaMax)
+    op.addInput(gamma)
+    op.addInput(gammaMin)
+    op.addInput(gammaMax)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Adds Tensor 'bias' to Tensor 'input' for Quantized types.
+///
+/// Broadcasts the values of bias on dimensions 0..N-2 of 'input'.
+///
+/// - Parameters:
+///     - bias: A 1D bias Tensor with size matching the last dimension of 'input'.
+///     - min_input: The float value that the lowest quantized input value represents.
+///     - max_input: The float value that the highest quantized input value represents.
+///     - min_bias: The float value that the lowest quantized bias value represents.
+///     - max_bias: The float value that the highest quantized bias value represents.
+///
+/// - Outputs:
+///     - min_out: The float value that the lowest quantized output value represents.
+///     - max_out: The float value that the highest quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizedBiasAdd<
+    T1: TensorFlowScalar,
+    T2: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<T1>,
+    bias: Tensor<T2>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minBias: Tensor<Float>,
+    maxBias: Tensor<Float>
+) -> (output: Tensor<OutType>, minOut: Tensor<Float>, maxOut: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedBiasAdd", nOutputs)
+    op.updateAttribute("T1", T1.tensorFlowDataType)
+    op.updateAttribute("T2", T2.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(bias)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minBias)
+    op.addInput(maxBias)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Concatenates quantized tensors along one dimension.
+///
+/// - Parameters:
+///     - concat_dim: 0-D.  The dimension along which to concatenate.  Must be in the
+///         range [0, rank(values)).
+///     - values: The `N` Tensors to concatenate. Their ranks and types must match,
+///         and their sizes must match in all dimensions except `concat_dim`.
+///     - input_mins: The minimum scalar values for each of the input tensors.
+///     - input_maxes: The maximum scalar values for each of the input tensors.
+///
+/// - Outputs:
+///     - output: A `Tensor` with the concatenation of values stacked along the
+///         `concat_dim` dimension.  This tensor's shape matches that of `values` except
+///         in `concat_dim` where it has the sum of the sizes.
+///     - output_min: The float value that the minimum quantized output value represents.
+///     - output_max: The float value that the maximum quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizedConcat<T: TensorFlowScalar>(
+    concatDim: Tensor<Int32>,
+    _ values: [Tensor<T>],
+    inputMins: [Tensor<Float>],
+    inputMaxes: [Tensor<Float>]
+) -> (output: Tensor<T>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConcat", nOutputs)
+    op.updateAttribute("N", values.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(concatDim)
+    op.addInputList(values)
+    op.addInputList(inputMins)
+    op.addInputList(inputMaxes)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes a 2D convolution given quantized 4D input and filter tensors.
+///
+/// The inputs are quantized tensors where the lowest value represents the real
+/// number of the associated minimum, and the highest represents the maximum.
+/// This means that you can only interpret the quantized output in the same way, by
+/// taking the returned minimum and maximum values into account.
+///
+/// - Parameters:
+///     - filter: filter's input_depth dimension must match input's depth dimensions.
+///     - min_input: The float value that the lowest quantized input value represents.
+///     - max_input: The float value that the highest quantized input value represents.
+///     - min_filter: The float value that the lowest quantized filter value represents.
+///     - max_filter: The float value that the highest quantized filter value represents.
+///
+/// - Attrs:
+///     - strides: The stride of the sliding window for each dimension of the input
+///         tensor.
+///     - padding: The type of padding algorithm to use.
+///     - dilations: 1-D tensor of length 4.  The dilation factor for each dimension of
+///         `input`. If set to k > 1, there will be k-1 skipped cells between each
+///         filter element on that dimension. The dimension order is determined by the
+///         value of `data_format`, see above for details. Dilations in the batch and
+///         depth dimensions must be 1.
+///
+/// - Outputs:
+///     - min_output: The float value that the lowest quantized output value represents.
+///     - max_output: The float value that the highest quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizedConv2D<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConv2D", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DAndRelu<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1],
+    paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConv2DAndRelu", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.updateAttribute("padding_list", paddingList)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DAndReluAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    minFreezedOutput: Tensor<Float>,
+    maxFreezedOutput: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1],
+    paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConv2DAndReluAndRequantize", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.updateAttribute("padding_list", paddingList)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    op.addInput(minFreezedOutput)
+    op.addInput(maxFreezedOutput)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    minFreezedOutput: Tensor<Float>,
+    maxFreezedOutput: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1],
+    paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConv2DAndRequantize", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.updateAttribute("padding_list", paddingList)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    op.addInput(minFreezedOutput)
+    op.addInput(maxFreezedOutput)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes QuantizedConv2D per channel.
+///
+/// - Parameters:
+///     - input: The original input tensor.
+///     - filter: The original filter tensor.
+///     - min_input: The minimum value of the input tensor
+///     - max_input: The maximum value of the input tensor.
+///     - min_filter: The minimum value of the filter tensor.
+///     - max_filter: The maximum value of the filter tensor.
+///
+/// - Attrs:
+///     - Tinput: The quantized type of input tensor that needs to be converted. 
+///     - Tfilter: The quantized type of filter tensor that needs to be converted. 
+///     - out_type: The quantized type of output tensor that needs to be converted.
+///     - strides: list of stride values.
+///     - dilations: list of dilation values.
+///
+/// - Outputs:
+///     - output: The output tensor.
+///     - min_output: The minimum value of the final output tensor.
+///     - max_output: The maximum value of the final output tensor.
+@inlinable @inline(__always)
+public static func quantizedConv2DPerChannel<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConv2DPerChannel", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBias<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    bias: Tensor<Float>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1],
+    paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConv2DWithBias", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.updateAttribute("padding_list", paddingList)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(bias)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBiasAndRelu<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    bias: Tensor<Float>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1],
+    paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConv2DWithBiasAndRelu", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.updateAttribute("padding_list", paddingList)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(bias)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBiasAndReluAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    Tbias: FloatingPoint & TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    bias: Tensor<Tbias>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    minFreezedOutput: Tensor<Float>,
+    maxFreezedOutput: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1],
+    paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConv2DWithBiasAndReluAndRequantize", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("Tbias", Tbias.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.updateAttribute("padding_list", paddingList)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(bias)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    op.addInput(minFreezedOutput)
+    op.addInput(maxFreezedOutput)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBiasAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    Tbias: FloatingPoint & TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    bias: Tensor<Tbias>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    minFreezedOutput: Tensor<Float>,
+    maxFreezedOutput: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1],
+    paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConv2DWithBiasAndRequantize", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("Tbias", Tbias.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.updateAttribute("padding_list", paddingList)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(bias)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    op.addInput(minFreezedOutput)
+    op.addInput(maxFreezedOutput)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBiasSignedSumAndReluAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    Tbias: FloatingPoint & TensorFlowScalar,
+    Tsummand: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    bias: Tensor<Tbias>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    minFreezedOutput: Tensor<Float>,
+    maxFreezedOutput: Tensor<Float>,
+    summand: Tensor<Tsummand>,
+    minSummand: Tensor<Float>,
+    maxSummand: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1],
+    paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConv2DWithBiasSignedSumAndReluAndRequantize", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("Tbias", Tbias.tensorFlowDataType)
+    op.updateAttribute("Tsummand", Tsummand.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.updateAttribute("padding_list", paddingList)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(bias)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    op.addInput(minFreezedOutput)
+    op.addInput(maxFreezedOutput)
+    op.addInput(summand)
+    op.addInput(minSummand)
+    op.addInput(maxSummand)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBiasSumAndRelu<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    bias: Tensor<Float>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    summand: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1],
+    paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConv2DWithBiasSumAndRelu", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.updateAttribute("padding_list", paddingList)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(bias)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    op.addInput(summand)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedConv2DWithBiasSumAndReluAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    Tbias: FloatingPoint & TensorFlowScalar,
+    Tsummand: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    bias: Tensor<Tbias>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    minFreezedOutput: Tensor<Float>,
+    maxFreezedOutput: Tensor<Float>,
+    summand: Tensor<Tsummand>,
+    minSummand: Tensor<Float>,
+    maxSummand: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1],
+    paddingList: [Int32]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedConv2DWithBiasSumAndReluAndRequantize", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("Tbias", Tbias.tensorFlowDataType)
+    op.updateAttribute("Tsummand", Tsummand.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.updateAttribute("padding_list", paddingList)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(bias)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    op.addInput(minFreezedOutput)
+    op.addInput(maxFreezedOutput)
+    op.addInput(summand)
+    op.addInput(minSummand)
+    op.addInput(maxSummand)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedDepthwiseConv2D<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedDepthwiseConv2D", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedDepthwiseConv2DWithBias<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    bias: Tensor<Float>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedDepthwiseConv2DWithBias", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(bias)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedDepthwiseConv2DWithBiasAndRelu<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    bias: Tensor<Float>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedDepthwiseConv2DWithBiasAndRelu", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(bias)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func quantizedDepthwiseConv2DWithBiasAndReluAndRequantize<
+    Tinput: TensorFlowScalar,
+    Tfilter: TensorFlowScalar,
+    Tbias: FloatingPoint & TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    filter: Tensor<Tfilter>,
+    bias: Tensor<Tbias>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    minFilter: Tensor<Float>,
+    maxFilter: Tensor<Float>,
+    minFreezedOutput: Tensor<Float>,
+    maxFreezedOutput: Tensor<Float>,
+    strides: [Int32],
+    padding: Padding,
+    dilations: [Int32] = [1, 1, 1, 1]
+) -> (output: Tensor<OutType>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("Tfilter", Tfilter.tensorFlowDataType)
+    op.updateAttribute("Tbias", Tbias.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.updateAttribute("dilations", dilations)
+    op.addInput(input)
+    op.addInput(filter)
+    op.addInput(bias)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    op.addInput(minFilter)
+    op.addInput(maxFilter)
+    op.addInput(minFreezedOutput)
+    op.addInput(maxFreezedOutput)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Quantized Instance normalization.
+///
+/// - Parameters:
+///     - x: A 4D input Tensor.
+///     - x_min: The value represented by the lowest quantized input.
+///     - x_max: The value represented by the highest quantized input.
+///
+/// - Attrs:
+///     - output_range_given: If True, `given_y_min` and `given_y_min`
+///         and `given_y_max` are used as the output range. Otherwise,
+///         the implementation computes the output range.
+///     - given_y_min: Output in `y_min` if `output_range_given` is True.
+///     - given_y_max: Output in `y_max` if `output_range_given` is True.
+///     - variance_epsilon: A small float number to avoid dividing by 0.
+///     - min_separation: Minimum value of `y_max - y_min`
+///
+/// - Outputs:
+///     - y: A 4D Tensor.
+///     - y_min: The value represented by the lowest quantized output.
+///     - y_max: The value represented by the highest quantized output.
+@inlinable @inline(__always)
+public static func quantizedInstanceNorm<T: TensorFlowScalar>(
+    _ x: Tensor<T>,
+    xMin: Tensor<Float>,
+    xMax: Tensor<Float>,
+    outputRangeGiven: Bool = false,
+    givenYMin: Double = 0,
+    givenYMax: Double = 0,
+    varianceEpsilon: Double = 1e-05,
+    minSeparation: Double = 0.001
+) -> (y: Tensor<T>, yMin: Tensor<Float>, yMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedInstanceNorm", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("output_range_given", outputRangeGiven)
+    op.updateAttribute("given_y_min", givenYMin)
+    op.updateAttribute("given_y_max", givenYMax)
+    op.updateAttribute("variance_epsilon", varianceEpsilon)
+    op.updateAttribute("min_separation", minSeparation)
+    op.addInput(x)
+    op.addInput(xMin)
+    op.addInput(xMax)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Perform a quantized matrix multiplication of  `a` by the matrix `b`.
+///
+/// The inputs must be two-dimensional matrices and the inner dimension of
+/// `a` (after being transposed if `transpose_a` is non-zero) must match the
+/// outer dimension of `b` (after being transposed if `transposed_b` is
+/// non-zero).
+///
+/// - Parameters:
+///     - a: Must be a two-dimensional tensor.
+///     - b: Must be a two-dimensional tensor.
+///     - min_a: The float value that the lowest quantized `a` value represents.
+///     - max_a: The float value that the highest quantized `a` value represents.
+///     - min_b: The float value that the lowest quantized `b` value represents.
+///     - max_b: The float value that the highest quantized `b` value represents.
+///
+/// - Attrs:
+///     - transpose_a: If true, `a` is transposed before multiplication.
+///     - transpose_b: If true, `b` is transposed before multiplication.
+///     - Tactivation: The type of output produced by activation function
+///         following this operation.
+///
+/// - Outputs:
+///     - min_out: The float value that the lowest quantized output value represents.
+///     - max_out: The float value that the highest quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizedMatMul<
+    T1: TensorFlowScalar,
+    T2: TensorFlowScalar,
+    Toutput: TensorFlowScalar
+>(
+    _ a: Tensor<T1>,
+    _ b: Tensor<T2>,
+    minA: Tensor<Float>,
+    maxA: Tensor<Float>,
+    minB: Tensor<Float>,
+    maxB: Tensor<Float>,
+    transposeA: Bool = false,
+    transposeB: Bool = false,
+    tactivation: TensorDataType
+) -> (out: Tensor<Toutput>, minOut: Tensor<Float>, maxOut: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedMatMul", nOutputs)
+    op.updateAttribute("T1", T1.tensorFlowDataType)
+    op.updateAttribute("T2", T2.tensorFlowDataType)
+    op.updateAttribute("Toutput", Toutput.tensorFlowDataType)
+    op.updateAttribute("transpose_a", transposeA)
+    op.updateAttribute("transpose_b", transposeB)
+    op.updateAttribute("Tactivation", tactivation)
+    op.addInput(a)
+    op.addInput(b)
+    op.addInput(minA)
+    op.addInput(maxA)
+    op.addInput(minB)
+    op.addInput(maxB)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Produces the max pool of the input tensor for quantized types.
+///
+/// - Parameters:
+///     - input: The 4D (batch x rows x cols x depth) Tensor to MaxReduce over.
+///     - min_input: The float value that the lowest quantized input value represents.
+///     - max_input: The float value that the highest quantized input value represents.
+///
+/// - Attrs:
+///     - ksize: The size of the window for each dimension of the input tensor.
+///         The length must be 4 to match the number of dimensions of the input.
+///     - strides: The stride of the sliding window for each dimension of the input
+///         tensor. The length must be 4 to match the number of dimensions of the input.
+///     - padding: The type of padding algorithm to use.
+///
+/// - Outputs:
+///     - min_output: The float value that the lowest quantized output value represents.
+///     - max_output: The float value that the highest quantized output value represents.
+@inlinable @inline(__always)
+public static func quantizedMaxPool<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    minInput: Tensor<Float>,
+    maxInput: Tensor<Float>,
+    ksize: [Int32],
+    strides: [Int32],
+    padding: Padding
+) -> (output: Tensor<T>, minOutput: Tensor<Float>, maxOutput: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedMaxPool", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("ksize", ksize)
+    op.updateAttribute("strides", strides)
+    op.updateAttribute("padding", padding.cName)
+    op.addInput(input)
+    op.addInput(minInput)
+    op.addInput(maxInput)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Returns x * y element-wise, working on quantized buffers.
+///
+/// - Parameters:
+///     - min_x: The float value that the lowest quantized `x` value represents.
+///     - max_x: The float value that the highest quantized `x` value represents.
+///     - min_y: The float value that the lowest quantized `y` value represents.
+///     - max_y: The float value that the highest quantized `y` value represents.
+///
+/// - Outputs:
+///     - min_z: The float value that the lowest quantized output value represents.
+///     - max_z: The float value that the highest quantized output value represents.
+///
+///         *NOTE*: `QuantizedMul` supports limited forms of broadcasting. More about
+///         broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func quantizedMul<
+    T1: TensorFlowScalar,
+    T2: TensorFlowScalar,
+    Toutput: TensorFlowScalar
+>(
+    _ x: Tensor<T1>,
+    _ y: Tensor<T2>,
+    minX: Tensor<Float>,
+    maxX: Tensor<Float>,
+    minY: Tensor<Float>,
+    maxY: Tensor<Float>
+) -> (z: Tensor<Toutput>, minZ: Tensor<Float>, maxZ: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedMul", nOutputs)
+    op.updateAttribute("T1", T1.tensorFlowDataType)
+    op.updateAttribute("T2", T2.tensorFlowDataType)
+    op.updateAttribute("Toutput", Toutput.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    op.addInput(minX)
+    op.addInput(maxX)
+    op.addInput(minY)
+    op.addInput(maxY)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes Quantized Rectified Linear: `max(features, 0)`
+///
+/// - Parameters:
+///     - min_features: The float value that the lowest quantized value represents.
+///     - max_features: The float value that the highest quantized value represents.
+///
+/// - Outputs:
+///     - activations: Has the same output shape as "features".
+///     - min_activations: The float value that the lowest quantized value represents.
+///     - max_activations: The float value that the highest quantized value represents.
+@inlinable @inline(__always)
+public static func quantizedRelu<
+    Tinput: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    features: Tensor<Tinput>,
+    minFeatures: Tensor<Float>,
+    maxFeatures: Tensor<Float>
+) -> (activations: Tensor<OutType>, minActivations: Tensor<Float>, maxActivations: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedRelu", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(features)
+    op.addInput(minFeatures)
+    op.addInput(maxFeatures)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes Quantized Rectified Linear 6: `min(max(features, 0), 6)`
+///
+/// - Parameters:
+///     - min_features: The float value that the lowest quantized value represents.
+///     - max_features: The float value that the highest quantized value represents.
+///
+/// - Outputs:
+///     - activations: Has the same output shape as "features".
+///     - min_activations: The float value that the lowest quantized value represents.
+///     - max_activations: The float value that the highest quantized value represents.
+@inlinable @inline(__always)
+public static func quantizedRelu6<
+    Tinput: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    features: Tensor<Tinput>,
+    minFeatures: Tensor<Float>,
+    maxFeatures: Tensor<Float>
+) -> (activations: Tensor<OutType>, minActivations: Tensor<Float>, maxActivations: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedRelu6", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(features)
+    op.addInput(minFeatures)
+    op.addInput(maxFeatures)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes Quantized Rectified Linear X: `min(max(features, 0), max_value)`
+///
+/// - Parameters:
+///     - min_features: The float value that the lowest quantized value represents.
+///     - max_features: The float value that the highest quantized value represents.
+///
+/// - Outputs:
+///     - activations: Has the same output shape as "features".
+///     - min_activations: The float value that the lowest quantized value represents.
+///     - max_activations: The float value that the highest quantized value represents.
+@inlinable @inline(__always)
+public static func quantizedReluX<
+    Tinput: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    features: Tensor<Tinput>,
+    maxValue: Tensor<Float>,
+    minFeatures: Tensor<Float>,
+    maxFeatures: Tensor<Float>
+) -> (activations: Tensor<OutType>, minActivations: Tensor<Float>, maxActivations: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedReluX", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(features)
+    op.addInput(maxValue)
+    op.addInput(minFeatures)
+    op.addInput(maxFeatures)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Reshapes a quantized tensor as per the Reshape op.
+///
+/// ```
+///
+/// - Parameters:
+///     - shape: Defines the shape of the output tensor.
+///     - input_min: The minimum value of the input.
+///     - input_max: The maximum value of the input.
+///
+/// - Outputs:
+///     - output_min: This value is copied from input_min.
+///     - output_max: This value is copied from input_max.
+@inlinable @inline(__always)
+public static func quantizedReshape<
+    T: TensorFlowScalar,
+    Tshape: BinaryInteger & TensorFlowScalar
+>(
+    _ tensor: Tensor<T>,
+    shape: Tensor<Tshape>,
+    inputMin: Tensor<Float>,
+    inputMax: Tensor<Float>
+) -> (output: Tensor<T>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedReshape", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tshape", Tshape.tensorFlowDataType)
+    op.addInput(tensor)
+    op.addInput(shape)
+    op.addInput(inputMin)
+    op.addInput(inputMax)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Resize quantized `images` to `size` using quantized bilinear interpolation.
+///
+/// Input images and output images must be quantized types.
+///
+/// - Parameters:
+///     - images: 4-D with shape `[batch, height, width, channels]`.
+///     - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+///         new size for the images.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
+///     aligned, preserving the values at the corner pixels. Defaults to false.
+///
+/// - Output resized_images: 4-D with shape
+///     `[batch, new_height, new_width, channels]`.
+@inlinable @inline(__always)
+public static func quantizedResizeBilinear<T: FloatingPoint & TensorFlowScalar>(
+    images: Tensor<T>,
+    size: Tensor<Int32>,
+    min: Tensor<Float>,
+    max: Tensor<Float>,
+    alignCorners: Bool = false,
+    halfPixelCenters: Bool = false
+) -> (resizedImages: Tensor<T>, outMin: Tensor<Float>, outMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("QuantizedResizeBilinear", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("align_corners", alignCorners)
+    op.updateAttribute("half_pixel_centers", halfPixelCenters)
+    op.addInput(images)
+    op.addInput(size)
+    op.addInput(min)
+    op.addInput(max)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Closes the given queue.
+///
+/// This operation signals that no more elements will be enqueued in the
+/// given queue. Subsequent Enqueue(Many) operations will fail.
+/// Subsequent Dequeue(Many) operations will continue to succeed if
+/// sufficient elements remain in the queue. Subsequent Dequeue(Many)
+/// operations that would block will fail immediately.
+///
+/// - Parameter handle: The handle to a queue.
+///
+/// - Attr cancel_pending_enqueues: If true, all pending enqueue requests that are
+///     blocked on the given queue will be canceled.
+@inlinable @inline(__always)
+public static func queueCloseV2(
+    handle: ResourceHandle,
+    cancelPendingEnqueues: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("QueueCloseV2", nOutputs)
+    op.updateAttribute("cancel_pending_enqueues", cancelPendingEnqueues)
+    op.addInput(handle)
+    op.execute()
+}
+
+/// Dequeues `n` tuples of one or more tensors from the given queue.
+///
+/// If the queue is closed and there are fewer than `n` elements, then an
+/// OutOfRange error is returned.
+///
+/// This operation concatenates queue-element component tensors along the
+/// 0th dimension to make a single component tensor.  All of the components
+/// in the dequeued tuple will have size `n` in the 0th dimension.
+///
+/// This operation has `k` outputs, where `k` is the number of components in
+/// the tuples stored in the given queue, and output `i` is the ith
+/// component of the dequeued tuple.
+///
+/// N.B. If the queue is empty, this operation will block until `n` elements
+/// have been dequeued (or 'timeout_ms' elapses, if specified).
+///
+/// - Parameters:
+///     - handle: The handle to a queue.
+///     - n: The number of tuples to dequeue.
+///
+/// - Attrs:
+///     - component_types: The type of each component in a tuple.
+///     - timeout_ms: If the queue has fewer than n elements, this operation
+///         will block for up to timeout_ms milliseconds.
+///         Note: This option is not supported yet.
+///
+/// - Output components: One or more tensors that were dequeued as a tuple.
+@inlinable @inline(__always)
+public static func queueDequeueManyV2<ComponentTypes: TensorGroup>(
+    handle: ResourceHandle,
+    n: Tensor<Int32>,
+    timeoutMs: Int64 = -1
+) -> ComponentTypes {
+  let nOutputs = Int(ComponentTypes._typeList.count)
+    let op = makeOp("QueueDequeueManyV2", nOutputs)
+    op.updateAttribute("component_types", ComponentTypes._typeList)
+    op.updateAttribute("timeout_ms", timeoutMs)
+    op.addInput(handle)
+    op.addInput(n)
+    return op.execute(Int(ComponentTypes._typeList.count))
+}
+
+/// Dequeues `n` tuples of one or more tensors from the given queue.
+///
+/// This operation is not supported by all queues.  If a queue does not support
+/// DequeueUpTo, then an Unimplemented error is returned.
+///
+/// If the queue is closed and there are more than 0 but less than `n`
+/// elements remaining, then instead of returning an OutOfRange error like
+/// QueueDequeueMany, less than `n` elements are returned immediately.  If
+/// the queue is closed and there are 0 elements left in the queue, then
+/// an OutOfRange error is returned just like in QueueDequeueMany.
+/// Otherwise the behavior is identical to QueueDequeueMany:
+///
+/// This operation concatenates queue-element component tensors along the
+/// 0th dimension to make a single component tensor.  All of the components
+/// in the dequeued tuple will have size n in the 0th dimension.
+///
+/// This operation has `k` outputs, where `k` is the number of components in
+/// the tuples stored in the given queue, and output `i` is the ith
+/// component of the dequeued tuple.
+///
+/// - Parameters:
+///     - handle: The handle to a queue.
+///     - n: The number of tuples to dequeue.
+///
+/// - Attrs:
+///     - component_types: The type of each component in a tuple.
+///     - timeout_ms: If the queue has fewer than n elements, this operation
+///         will block for up to timeout_ms milliseconds.
+///         Note: This option is not supported yet.
+///
+/// - Output components: One or more tensors that were dequeued as a tuple.
+@inlinable @inline(__always)
+public static func queueDequeueUpToV2<ComponentTypes: TensorGroup>(
+    handle: ResourceHandle,
+    n: Tensor<Int32>,
+    timeoutMs: Int64 = -1
+) -> ComponentTypes {
+  let nOutputs = Int(ComponentTypes._typeList.count)
+    let op = makeOp("QueueDequeueUpToV2", nOutputs)
+    op.updateAttribute("component_types", ComponentTypes._typeList)
+    op.updateAttribute("timeout_ms", timeoutMs)
+    op.addInput(handle)
+    op.addInput(n)
+    return op.execute(Int(ComponentTypes._typeList.count))
+}
+
+/// Dequeues a tuple of one or more tensors from the given queue.
+///
+/// This operation has k outputs, where k is the number of components
+/// in the tuples stored in the given queue, and output i is the ith
+/// component of the dequeued tuple.
+///
+/// N.B. If the queue is empty, this operation will block until an element
+/// has been dequeued (or 'timeout_ms' elapses, if specified).
+///
+/// - Parameter handle: The handle to a queue.
+///
+/// - Attrs:
+///     - component_types: The type of each component in a tuple.
+///     - timeout_ms: If the queue is empty, this operation will block for up to
+///         timeout_ms milliseconds.
+///         Note: This option is not supported yet.
+///
+/// - Output components: One or more tensors that were dequeued as a tuple.
+@inlinable @inline(__always)
+public static func queueDequeueV2<ComponentTypes: TensorGroup>(
+    handle: ResourceHandle,
+    timeoutMs: Int64 = -1
+) -> ComponentTypes {
+  let nOutputs = Int(ComponentTypes._typeList.count)
+    let op = makeOp("QueueDequeueV2", nOutputs)
+    op.updateAttribute("component_types", ComponentTypes._typeList)
+    op.updateAttribute("timeout_ms", timeoutMs)
+    op.addInput(handle)
+    return op.execute(Int(ComponentTypes._typeList.count))
+}
+
+/// Enqueues zero or more tuples of one or more tensors in the given queue.
+///
+/// This operation slices each component tensor along the 0th dimension to
+/// make multiple queue elements. All of the tuple components must have the
+/// same size in the 0th dimension.
+///
+/// The components input has k elements, which correspond to the components of
+/// tuples stored in the given queue.
+///
+/// N.B. If the queue is full, this operation will block until the given
+/// elements have been enqueued (or 'timeout_ms' elapses, if specified).
+///
+/// - Parameters:
+///     - handle: The handle to a queue.
+///     - components: One or more tensors from which the enqueued tensors should
+///         be taken.
+///
+/// - Attr timeout_ms: If the queue is too full, this operation will block for up
+///     to timeout_ms milliseconds.
+///     Note: This option is not supported yet.
+@inlinable @inline(__always)
+public static func queueEnqueueManyV2<Tcomponents: TensorArrayProtocol>(
+    handle: ResourceHandle,
+    components: Tcomponents,
+    timeoutMs: Int64 = -1
+) {
+  let nOutputs = 0
+    let op = makeOp("QueueEnqueueManyV2", nOutputs)
+    op.updateAttribute("Tcomponents", components._typeList)
+    op.updateAttribute("timeout_ms", timeoutMs)
+    op.addInput(handle)
+    op.addInputList(components)
+    op.execute()
+}
+
+/// Enqueues a tuple of one or more tensors in the given queue.
+///
+/// The components input has k elements, which correspond to the components of
+/// tuples stored in the given queue.
+///
+/// N.B. If the queue is full, this operation will block until the given
+/// element has been enqueued (or 'timeout_ms' elapses, if specified).
+///
+/// - Parameters:
+///     - handle: The handle to a queue.
+///     - components: One or more tensors from which the enqueued tensors should be taken.
+///
+/// - Attr timeout_ms: If the queue is full, this operation will block for up to
+///     timeout_ms milliseconds.
+///     Note: This option is not supported yet.
+@inlinable @inline(__always)
+public static func queueEnqueueV2<Tcomponents: TensorArrayProtocol>(
+    handle: ResourceHandle,
+    components: Tcomponents,
+    timeoutMs: Int64 = -1
+) {
+  let nOutputs = 0
+    let op = makeOp("QueueEnqueueV2", nOutputs)
+    op.updateAttribute("Tcomponents", components._typeList)
+    op.updateAttribute("timeout_ms", timeoutMs)
+    op.addInput(handle)
+    op.addInputList(components)
+    op.execute()
+}
+
+/// Returns true if queue is closed.
+///
+/// This operation returns true if the queue is closed and false if the queue
+/// is open.
+///
+/// - Parameter handle: The handle to a queue.
+@inlinable @inline(__always)
+public static func queueIsClosedV2(
+    handle: ResourceHandle
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("QueueIsClosedV2", nOutputs)
+    op.addInput(handle)
+    return op.execute(Int(1))
+}
+
+/// Computes the number of elements in the given queue.
+///
+/// - Parameter handle: The handle to a queue.
+///
+/// - Output size: The number of elements in the given queue.
+@inlinable @inline(__always)
+public static func queueSizeV2(
+    handle: ResourceHandle
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("QueueSizeV2", nOutputs)
+    op.addInput(handle)
+    return op.execute(Int(1))
+}
+
+/// Converts one or more images from RGB to HSV.
+///
+/// Outputs a tensor of the same shape as the `images` tensor, containing the HSV
+/// value of the pixels. The output is only well defined if the value in `images`
+/// are in `[0,1]`.
+///
+/// `output[..., 0]` contains hue, `output[..., 1]` contains saturation, and
+/// `output[..., 2]` contains value. All HSV values are in `[0,1]`. A hue of 0
+/// corresponds to pure red, hue 1/3 is pure green, and 2/3 is pure blue.
+///
+/// - Parameter images: 1-D or higher rank. RGB data to convert. Last dimension must be size 3.
+///
+/// - Output output: `images` converted to HSV.
+@inlinable @inline(__always)
+public static func rGBToHSV<T: FloatingPoint & TensorFlowScalar>(
+    images: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("RGBToHSV", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(images)
+    return op.execute(Int(1))
+}
+
+/// Gather ragged slices from `params` axis `0` according to `indices`.
+///
+/// Outputs a `RaggedTensor` output composed from `output_dense_values` and
+/// `output_nested_splits`, such that:
+///
+/// ```python
+/// output.shape = indices.shape + params.shape[1:]
+/// output.ragged_rank = indices.shape.ndims + params.ragged_rank
+/// output[i...j, d0...dn] = params[indices[i...j], d0...dn]
+/// ```
+///
+/// where
+///
+/// * `params =
+///    ragged.from_nested_row_splits(params_dense_values, params_nested_splits)`
+///    provides the values that should be gathered.
+/// * `indices` ia a dense tensor with dtype `int32` or `int64`, indicating which
+///    values should be gathered.
+/// * `output =
+///    ragged.from_nested_row_splits(output_dense_values, output_nested_splits)`
+///    is the output tensor.
+///
+/// (Note: This c++ op is used to implement the higher-level python
+/// `tf.ragged.gather` op, which also supports ragged indices.)
+///
+///
+/// - Parameters:
+///     - params_nested_splits: The `nested_row_splits` tensors that define the row-partitioning for the
+///         `params` RaggedTensor input.
+///     - params_dense_values: The `flat_values` for the `params` RaggedTensor. There was a terminology change
+///         at the python level from dense_values to flat_values, so dense_values is the
+///         deprecated name.
+///     - indices: Indices in the outermost dimension of `params` of the values that should be
+///         gathered.
+///
+/// - Attrs:
+///     - PARAMS_RAGGED_RANK: The ragged rank of the `params` RaggedTensor. `params_nested_splits` should
+///         contain this number of `row_splits` tensors. This value should equal
+///         `params.ragged_rank`.
+///     - OUTPUT_RAGGED_RANK: The ragged rank of the output RaggedTensor. `output_nested_splits` will contain
+///         this number of `row_splits` tensors. This value should equal
+///         `indices.shape.ndims + params.ragged_rank - 1`.
+///
+/// - Outputs:
+///     - output_nested_splits: The `nested_row_splits` tensors that define the row-partitioning for the
+///         returned RaggedTensor.
+///     - output_dense_values: The `flat_values` for the returned RaggedTensor.
+@inlinable @inline(__always)
+public static func raggedGather<
+    Tvalues: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    paramsNestedSplits: [Tensor<Int64>],
+    paramsDenseValues: Tensor<Tvalues>,
+    indices: Tensor<Tindices>,
+    oUTPUTRAGGEDRANK: Int64
+) -> (outputNestedSplits: [Tensor<Int64>], outputDenseValues: Tensor<Tvalues>) {
+  let nOutputs = Int(oUTPUTRAGGEDRANK) + Int(1)
+    let op = makeOp("RaggedGather", nOutputs)
+    op.updateAttribute("Tvalues", Tvalues.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("PARAMS_RAGGED_RANK", paramsNestedSplits.count)
+    op.updateAttribute("OUTPUT_RAGGED_RANK", oUTPUTRAGGEDRANK)
+    op.addInputList(paramsNestedSplits)
+    op.addInput(paramsDenseValues)
+    op.addInput(indices)
+    return op.execute(Int(oUTPUTRAGGEDRANK), Int(1))
+}
+
+/// Returns a `RaggedTensor` containing the specified sequences of numbers.
+///
+///
+/// Returns a `RaggedTensor` `result` composed from `rt_dense_values` and
+/// `rt_nested_splits`, such that
+/// `result[i] = range(starts[i], limits[i], deltas[i])`.
+///
+/// ```python
+/// >>> (rt_nested_splits, rt_dense_values) = gen_ragged_ops.ragged_range(
+/// ...     starts=[2, 5, 8], limits=[3, 5, 12], deltas=1)
+/// >>> result = ragged.from_nested_row_splits(rt_dense_values, rt_nested_splits)
+/// >>> print result.eval().tolist()
+/// [[2],               # result[0] = range(2, 3)
+///  [],                # result[1] = range(5, 5)
+///  [8, 9, 10, 11]]    # result[2] = range(8, 12)
+/// ```
+///
+/// The input tensors `starts`, `limits`, and `deltas` may be scalars or vectors.
+/// The vector inputs must all have the same size.  Scalar inputs are broadcast
+/// to match the size of the vector inputs.
+///
+/// - Parameters:
+///     - starts: The starts of each range.
+///     - limits: The limits of each range.
+///     - deltas: The deltas of each range.
+///
+/// - Outputs:
+///     - rt_nested_splits: The `row_splits` for the returned `RaggedTensor`.
+///     - rt_dense_values: The `flat_values` for the returned `RaggedTensor`.
+@inlinable @inline(__always)
+public static func raggedRange<T: Numeric & TensorFlowScalar>(
+    starts: Tensor<T>,
+    limits: Tensor<T>,
+    deltas: Tensor<T>
+) -> (rtNestedSplits: Tensor<Int64>, rtDenseValues: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("RaggedRange", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(starts)
+    op.addInput(limits)
+    op.addInput(deltas)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Converts a `RaggedTensor` into a `SparseTensor` with the same values.
+///
+/// input=ragged.from_nested_row_splits(rt_dense_values, rt_nested_splits)
+/// output=SparseTensor(indices=sparse_indices, values=sparse_values,
+///                     dense_shape=sparse_dense_shape)
+///
+/// - Parameters:
+///     - rt_nested_splits: The `row_splits` for the `RaggedTensor`.
+///     - rt_dense_values: The `flat_values` for the `RaggedTensor`.
+///
+/// - Attr RAGGED_RANK: The ragged rank of the input RaggedTensor.  `rt_nested_splits` should contain
+///     this number of ragged-splits tensors.  This value should equal
+///     `input.ragged_rank`.
+///
+/// - Outputs:
+///     - sparse_indices: The indices for the `SparseTensor`.
+///     - sparse_values: The values of the `SparseTensor`.
+///     - sparse_dense_shape: `sparse_dense_shape` is a tight bounding box of the input `RaggedTensor`.
+@inlinable @inline(__always)
+public static func raggedTensorToSparse<T: TensorFlowScalar>(
+    rtNestedSplits: [Tensor<Int64>],
+    rtDenseValues: Tensor<T>
+) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<T>, sparseDenseShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("RaggedTensorToSparse", nOutputs)
+    op.updateAttribute("RAGGED_RANK", rtNestedSplits.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInputList(rtNestedSplits)
+    op.addInput(rtDenseValues)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Randomly crop `image`.
+///
+/// `size` is a 1-D int64 tensor with 2 elements representing the crop height and
+/// width.  The values must be non negative.
+///
+/// This Op picks a random location in `image` and crops a `height` by `width`
+/// rectangle from that location.  The random location is picked so the cropped
+/// area will fit inside the original image.
+///
+/// - Parameters:
+///     - image: 3-D of shape `[height, width, channels]`.
+///     - size: 1-D of length 2 containing: `crop_height`, `crop_width`..
+///
+/// - Attrs:
+///     - seed: If either seed or seed2 are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: An second seed to avoid seed collision.
+///
+/// - Output output: 3-D of shape `[crop_height, crop_width, channels].`
+@inlinable @inline(__always)
+public static func randomCrop<T: Numeric & TensorFlowScalar>(
+    image: Tensor<T>,
+    size: Tensor<Int64>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("RandomCrop", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(image)
+    op.addInput(size)
+    return op.execute(Int(1))
+}
+
+/// Outputs random values from the Gamma distribution(s) described by alpha.
+///
+/// This op uses the algorithm by Marsaglia et al. to acquire samples via
+/// transformation-rejection from pairs of uniform and normal random variables.
+/// See http://dl.acm.org/citation.cfm?id=358414
+///
+/// - Parameters:
+///     - shape: 1-D integer tensor. Shape of independent samples to draw from each
+///         distribution described by the shape parameters given in alpha.
+///     - alpha: A tensor in which each scalar is a "shape" parameter describing the
+///         associated gamma distribution.
+///
+/// - Attrs:
+///     - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: A second seed to avoid seed collision.
+///
+/// - Output output: A tensor with shape `shape + shape(alpha)`. Each slice
+///     `[:, ..., :, i0, i1, ...iN]` contains the samples drawn for
+///     `alpha[i0, i1, ...iN]`. The dtype of the output matches the dtype of alpha.
+@inlinable @inline(__always)
+public static func randomGamma<
+    S: BinaryInteger & TensorFlowScalar,
+    T: FloatingPoint & TensorFlowScalar
+>(
+    shape: Tensor<S>,
+    alpha: Tensor<T>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("RandomGamma", nOutputs)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("S", S.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(shape)
+    op.addInput(alpha)
+    return op.execute(Int(1))
+}
+
+/// Computes the derivative of a Gamma random sample w.r.t. `alpha`.
+@inlinable @inline(__always)
+public static func randomGammaGrad<T: FloatingPoint & TensorFlowScalar>(
+    alpha: Tensor<T>,
+    sample: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("RandomGammaGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(alpha)
+    op.addInput(sample)
+    return op.execute(Int(1))
+}
+
+/// Use RandomPoissonV2 instead.
+@inlinable @inline(__always)
+public static func randomPoisson<
+    S: BinaryInteger & TensorFlowScalar,
+    Dtype: FloatingPoint & TensorFlowScalar
+>(
+    shape: Tensor<S>,
+    rate: Tensor<Dtype>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("RandomPoisson", nOutputs)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("S", S.tensorFlowDataType)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(shape)
+    op.addInput(rate)
+    return op.execute(Int(1))
+}
+
+/// Outputs random values from the Poisson distribution(s) described by rate.
+///
+/// This op uses two algorithms, depending on rate. If rate >= 10, then
+/// the algorithm by Hormann is used to acquire samples via
+/// transformation-rejection.
+/// See http://www.sciencedirect.com/science/article/pii/0167668793909974.
+///
+/// Otherwise, Knuth's algorithm is used to acquire samples via multiplying uniform
+/// random variables.
+/// See Donald E. Knuth (1969). Seminumerical Algorithms. The Art of Computer
+/// Programming, Volume 2. Addison Wesley
+///
+/// - Parameters:
+///     - shape: 1-D integer tensor. Shape of independent samples to draw from each
+///         distribution described by the shape parameters given in rate.
+///     - rate: A tensor in which each scalar is a "rate" parameter describing the
+///         associated poisson distribution.
+///
+/// - Attrs:
+///     - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: A second seed to avoid seed collision.
+///
+/// - Output output: A tensor with shape `shape + shape(rate)`. Each slice
+///     `[:, ..., :, i0, i1, ...iN]` contains the samples drawn for
+///     `rate[i0, i1, ...iN]`.
+@inlinable @inline(__always)
+public static func randomPoissonV2<
+    S: BinaryInteger & TensorFlowScalar,
+    R: Numeric & TensorFlowScalar,
+    Dtype: Numeric & TensorFlowScalar
+>(
+    shape: Tensor<S>,
+    rate: Tensor<R>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("RandomPoissonV2", nOutputs)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("S", S.tensorFlowDataType)
+    op.updateAttribute("R", R.tensorFlowDataType)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(shape)
+    op.addInput(rate)
+    return op.execute(Int(1))
+}
+
+/// Randomly shuffles a tensor along its first dimension.
+///
+///   The tensor is shuffled along dimension 0, such that each `value[j]` is mapped
+///   to one and only one `output[i]`. For example, a mapping that might occur for a
+///   3x2 tensor is:
+///
+/// ```
+/// [[1, 2],       [[5, 6],
+///  [3, 4],  ==>   [1, 2],
+///  [5, 6]]        [3, 4]]
+/// ```
+///
+/// - Parameter value: The tensor to be shuffled.
+///
+/// - Attrs:
+///     - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: A second seed to avoid seed collision.
+///
+/// - Output output: A tensor of same shape and type as `value`, shuffled along its first
+///     dimension.
+@inlinable @inline(__always)
+public static func randomShuffle<T: TensorFlowScalar>(
+    value: Tensor<T>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("RandomShuffle", nOutputs)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(value)
+    return op.execute(Int(1))
+}
+
+/// A queue that randomizes the order of elements.
+///
+/// - Attrs:
+///     - component_types: The type of each component in a value.
+///     - shapes: The shape of each component in a value. The length of this attr must
+///         be either 0 or the same as the length of component_types. If the length of
+///         this attr is 0, the shapes of queue elements are not constrained, and
+///         only one element may be dequeued at a time.
+///     - capacity: The upper bound on the number of elements in this queue.
+///         Negative numbers mean no limit.
+///     - min_after_dequeue: Dequeue will block unless there would be this
+///         many elements after the dequeue or the queue is closed. This
+///         ensures a minimum level of mixing of elements.
+///     - seed: If either seed or seed2 is set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, a random seed is used.
+///     - seed2: A second seed to avoid seed collision.
+///     - container: If non-empty, this queue is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this queue will be shared under the given name
+///         across multiple sessions.
+///
+/// - Output handle: The handle to the queue.
+@inlinable @inline(__always)
+public static func randomShuffleQueueV2(
+    componentTypes: [TensorDataType],
+    shapes: [TensorShape?],
+    capacity: Int64 = -1,
+    minAfterDequeue: Int64 = 0,
+    seed: Int64 = 0,
+    seed2: Int64 = 0,
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("RandomShuffleQueueV2", nOutputs)
+    op.updateAttribute("component_types", componentTypes)
+    op.updateAttribute("shapes", shapes)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("min_after_dequeue", minAfterDequeue)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Outputs random values from a normal distribution.
+///
+/// The generated values will have mean 0 and standard deviation 1.
+///
+/// - Parameter shape: The shape of the output tensor.
+///
+/// - Attrs:
+///     - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: A second seed to avoid seed collision.
+///     - dtype: The type of the output.
+///
+/// - Output output: A tensor of the specified shape filled with random normal values.
+@inlinable @inline(__always)
+public static func randomStandardNormal<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar
+>(
+    shape: Tensor<T>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("RandomStandardNormal", nOutputs)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Outputs random values from a uniform distribution.
+///
+/// The generated values follow a uniform distribution in the range `[0, 1)`. The
+/// lower bound 0 is included in the range, while the upper bound 1 is excluded.
+///
+/// - Parameter shape: The shape of the output tensor.
+///
+/// - Attrs:
+///     - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: A second seed to avoid seed collision.
+///     - dtype: The type of the output.
+///
+/// - Output output: A tensor of the specified shape filled with uniform random values.
+@inlinable @inline(__always)
+public static func randomUniform<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar
+>(
+    shape: Tensor<T>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("RandomUniform", nOutputs)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Outputs random integers from a uniform distribution.
+///
+/// The generated values are uniform integers in the range `[minval, maxval)`.
+/// The lower bound `minval` is included in the range, while the upper bound
+/// `maxval` is excluded.
+///
+/// The random integers are slightly biased unless `maxval - minval` is an exact
+/// power of two.  The bias is small for values of `maxval - minval` significantly
+/// smaller than the range of the output (either `2^32` or `2^64`).
+///
+/// - Parameters:
+///     - shape: The shape of the output tensor.
+///     - minval: 0-D.  Inclusive lower bound on the generated integers.
+///     - maxval: 0-D.  Exclusive upper bound on the generated integers.
+///
+/// - Attrs:
+///     - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: A second seed to avoid seed collision.
+///
+/// - Output output: A tensor of the specified shape filled with uniform random integers.
+@inlinable @inline(__always)
+public static func randomUniformInt<
+    Tout: BinaryInteger & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar
+>(
+    shape: Tensor<T>,
+    minval: Tensor<Tout>,
+    maxval: Tensor<Tout>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<Tout> {
+  let nOutputs = Int(1)
+    let op = makeOp("RandomUniformInt", nOutputs)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("Tout", Tout.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(shape)
+    op.addInput(minval)
+    op.addInput(maxval)
+    return op.execute(Int(1))
+}
+
+/// Creates a sequence of numbers.
+///
+/// This operation creates a sequence of numbers that begins at `start` and
+/// extends by increments of `delta` up to but not including `limit`.
+///
+/// For example:
+///
+/// ```
+/// # 'start' is 3
+/// # 'limit' is 18
+/// # 'delta' is 3
+/// tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]
+/// ```
+///
+/// - Parameters:
+///     - start: 0-D (scalar). First entry in the sequence.
+///     - limit: 0-D (scalar). Upper limit of sequence, exclusive.
+///     - delta: 0-D (scalar). Optional. Default is 1. Number that increments `start`.
+///
+/// - Output output: 1-D.
+@inlinable @inline(__always)
+public static func range<Tidx: Numeric & TensorFlowScalar>(
+    start: Tensor<Tidx>,
+    limit: Tensor<Tidx>,
+    delta: Tensor<Tidx>
+) -> Tensor<Tidx> {
+  let nOutputs = Int(1)
+    let op = makeOp("Range", nOutputs)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(start)
+    op.addInput(limit)
+    op.addInput(delta)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset with a range of values. Corresponds to python's xrange.
+///
+/// - Parameters:
+///     - start: corresponds to start in python's xrange().
+///     - stop: corresponds to stop in python's xrange().
+///     - step: corresponds to step in python's xrange().
+@inlinable @inline(__always)
+public static func rangeDataset(
+    start: Tensor<Int64>,
+    stop: Tensor<Int64>,
+    step: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("RangeDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(start)
+    op.addInput(stop)
+    op.addInput(step)
+    return op.execute(Int(1))
+}
+
+/// Returns the rank of a tensor.
+///
+/// This operation returns an integer representing the rank of `input`.
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
+/// # shape of tensor 't' is [2, 2, 3]
+/// rank(t) ==> 3
+/// ```
+///
+/// **Note**: The rank of a tensor is not the same as the rank of a matrix. The rank
+/// of a tensor is the number of indices required to uniquely select each element
+/// of the tensor. Rank is also known as "order", "degree", or "ndims."
+@inlinable @inline(__always)
+public static func rank<T: TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("Rank", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Reads and outputs the entire contents of the input filename.
+@inlinable @inline(__always)
+public static func readFile(
+    filename: StringTensor
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("ReadFile", nOutputs)
+    op.addInput(filename)
+    return op.execute(Int(1))
+}
+
+/// Reads the value of a variable.
+///
+/// The tensor returned by this operation is immutable.
+///
+/// The value returned by this operation is guaranteed to be influenced by all the
+/// writes on which this operation depends directly or indirectly, and to not be
+/// influenced by any of the writes which depend directly or indirectly on this
+/// operation.
+///
+/// - Parameter resource: handle to the resource in which to store the variable.
+///
+/// - Attr dtype: the dtype of the value.
+@inlinable @inline(__always)
+public static func readVariableOp<Dtype: TensorFlowScalar>(
+    resource: ResourceHandle
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("ReadVariableOp", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(resource)
+    return op.execute(Int(1))
+}
+
+/// Returns the number of records this Reader has produced.
+///
+/// This is the same as the number of ReaderRead executions that have
+/// succeeded.
+///
+/// - Parameter reader_handle: Handle to a Reader.
+@inlinable @inline(__always)
+public static func readerNumRecordsProducedV2(
+    readerHandle: ResourceHandle
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("ReaderNumRecordsProducedV2", nOutputs)
+    op.addInput(readerHandle)
+    return op.execute(Int(1))
+}
+
+/// Returns the number of work units this Reader has finished processing.
+///
+/// - Parameter reader_handle: Handle to a Reader.
+@inlinable @inline(__always)
+public static func readerNumWorkUnitsCompletedV2(
+    readerHandle: ResourceHandle
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("ReaderNumWorkUnitsCompletedV2", nOutputs)
+    op.addInput(readerHandle)
+    return op.execute(Int(1))
+}
+
+/// Returns up to `num_records` (key, value) pairs produced by a Reader.
+///
+/// Will dequeue from the input queue if necessary (e.g. when the
+/// Reader needs to start reading from a new file since it has finished
+/// with the previous file).
+/// It may return less than `num_records` even before the last batch.
+///
+/// - Parameters:
+///     - reader_handle: Handle to a `Reader`.
+///     - queue_handle: Handle to a `Queue`, with string work items.
+///     - num_records: number of records to read from `Reader`.
+///
+/// - Outputs:
+///     - keys: A 1-D tensor.
+///     - values: A 1-D tensor.
+@inlinable @inline(__always)
+public static func readerReadUpToV2(
+    readerHandle: ResourceHandle,
+    queueHandle: ResourceHandle,
+    numRecords: Tensor<Int64>
+) -> (keys: StringTensor, values: StringTensor) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("ReaderReadUpToV2", nOutputs)
+    op.addInput(readerHandle)
+    op.addInput(queueHandle)
+    op.addInput(numRecords)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Returns the next record (key, value pair) produced by a Reader.
+///
+/// Will dequeue from the input queue if necessary (e.g. when the
+/// Reader needs to start reading from a new file since it has finished
+/// with the previous file).
+///
+/// - Parameters:
+///     - reader_handle: Handle to a Reader.
+///     - queue_handle: Handle to a Queue, with string work items.
+///
+/// - Outputs:
+///     - key: A scalar.
+///     - value: A scalar.
+@inlinable @inline(__always)
+public static func readerReadV2(
+    readerHandle: ResourceHandle,
+    queueHandle: ResourceHandle
+) -> (key: StringTensor, value: StringTensor) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("ReaderReadV2", nOutputs)
+    op.addInput(readerHandle)
+    op.addInput(queueHandle)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Restore a Reader to its initial clean state.
+///
+/// - Parameter reader_handle: Handle to a Reader.
+@inlinable @inline(__always)
+public static func readerResetV2(
+    readerHandle: ResourceHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("ReaderResetV2", nOutputs)
+    op.addInput(readerHandle)
+    op.execute()
+}
+
+/// Restore a reader to a previously saved state.
+///
+/// Not all Readers support being restored, so this can produce an
+/// Unimplemented error.
+///
+/// - Parameters:
+///     - reader_handle: Handle to a Reader.
+///     - state: Result of a ReaderSerializeState of a Reader with type
+///         matching reader_handle.
+@inlinable @inline(__always)
+public static func readerRestoreStateV2(
+    readerHandle: ResourceHandle,
+    state: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("ReaderRestoreStateV2", nOutputs)
+    op.addInput(readerHandle)
+    op.addInput(state)
+    op.execute()
+}
+
+/// Produce a string tensor that encodes the state of a Reader.
+///
+/// Not all Readers support being serialized, so this can produce an
+/// Unimplemented error.
+///
+/// - Parameter reader_handle: Handle to a Reader.
+@inlinable @inline(__always)
+public static func readerSerializeStateV2(
+    readerHandle: ResourceHandle
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("ReaderSerializeStateV2", nOutputs)
+    op.addInput(readerHandle)
+    return op.execute(Int(1))
+}
+
+/// Returns the real part of a complex number.
+///
+/// Given a tensor `input` of complex numbers, this operation returns a tensor of
+/// type `float` that is the real part of each element in `input`. All elements in
+/// `input` must be complex numbers of the form \\(a + bj\\), where *a* is the real
+///  part returned by this operation and *b* is the imaginary part.
+///
+/// For example:
+///
+/// ```
+/// # tensor 'input' is [-2.25 + 4.75j, 3.25 + 5.75j]
+/// tf.real(input) ==> [-2.25, 3.25]
+/// ```
+@inlinable @inline(__always)
+public static func real<
+    T: TensorFlowScalar,
+    Tout: FloatingPoint & TensorFlowScalar
+>(
+    _ input: Tensor<T>
+) -> Tensor<Tout> {
+  let nOutputs = Int(1)
+    let op = makeOp("Real", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tout", Tout.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Returns x / y element-wise for real types.
+///
+/// If `x` and `y` are reals, this will return the floating-point division.
+///
+/// *NOTE*: `Div` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func realDiv<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("RealDiv", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Computes the reciprocal of x element-wise.
+///
+/// I.e., \\(y = 1 / x\\).
+@inlinable @inline(__always)
+public static func reciprocal<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Reciprocal", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient for the inverse of `x` wrt its input.
+///
+/// Specifically, `grad = -dy * y*y`, where `y = 1/x`, and `dy`
+/// is the corresponding input gradient.
+@inlinable @inline(__always)
+public static func reciprocalGrad<T: FloatingPoint & TensorFlowScalar>(
+    _ y: Tensor<T>,
+    dy: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ReciprocalGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(y)
+    op.addInput(dy)
+    return op.execute(Int(1))
+}
+
+/// Emits randomized records.
+///
+/// - Attrs:
+///     - file_pattern: Glob pattern for the data files.
+///     - file_random_seed: Random seeds used to produce randomized records.
+///     - file_shuffle_shift_ratio: Shifts the list of files after the list is randomly
+///         shuffled.
+///     - file_buffer_size: The randomization shuffling buffer.
+///     - file_parallelism: How many sstables are opened and concurrently iterated over.
+///     - batch_size: The batch size.
+///     - compression_type: The type of compression for the file. Currently ZLIB and
+///         GZIP are supported. Defaults to none.
+///
+/// - Output records: A tensor of shape [batch_size].
+@inlinable @inline(__always)
+public static func recordInput(
+    filePattern: String,
+    fileRandomSeed: Int64 = 301,
+    fileShuffleShiftRatio: Double = 0,
+    fileBufferSize: Int64 = 10000,
+    fileParallelism: Int64 = 16,
+    batchSize: Int64 = 32,
+    compressionType: String
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("RecordInput", nOutputs)
+    op.updateAttribute("file_pattern", filePattern)
+    op.updateAttribute("file_random_seed", fileRandomSeed)
+    op.updateAttribute("file_shuffle_shift_ratio", fileShuffleShiftRatio)
+    op.updateAttribute("file_buffer_size", fileBufferSize)
+    op.updateAttribute("file_parallelism", fileParallelism)
+    op.updateAttribute("batch_size", batchSize)
+    op.updateAttribute("compression_type", compressionType)
+    return op.execute(Int(1))
+}
+
+/// An op that receives embedding activations on the TPU.
+///
+/// The TPU system performs the embedding lookups and aggregations specified by
+/// the arguments to TPUEmbeddingEnqueue(Integer/Sparse/SparseTensor)Batch. The
+/// results of these aggregations are visible to the Tensorflow Graph as the
+/// outputs of a RecvTPUEmbeddingActivations op. This op returns a list containing
+/// one Tensor of activations per table specified in the model. There can be at
+/// most one RecvTPUEmbeddingActivations op in the TPU graph.
+///
+/// - Attrs:
+///     - num_outputs: The number of output activation tensors, equal to the number of
+///         embedding tables in the model.
+///     - config: Serialized TPUEmbeddingConfiguration proto.
+///
+/// - Output outputs: A TensorList of embedding activations containing one Tensor per
+///     embedding table in the model.
+@inlinable @inline(__always)
+public static func recvTPUEmbeddingActivations(
+    numOutputs: Int64,
+    config: String
+) -> [Tensor<Float>] {
+  let nOutputs = Int(numOutputs)
+    let op = makeOp("RecvTPUEmbeddingActivations", nOutputs)
+    op.updateAttribute("num_outputs", numOutputs)
+    op.updateAttribute("config", config)
+    return op.execute(Int(numOutputs))
+}
+
+/// Reduces the input dataset to a singleton using a reduce function.
+///
+/// - Parameters:
+///     - input_dataset: A variant tensor representing the input dataset.
+///     - initial_state: A nested structure of tensors, representing the initial state of the
+///         transformation.
+///
+/// - Attr f: A function that maps `(old_state, input_element)` to `new_state`. It must take
+///     two arguments and return a nested structures of tensors. The structure of
+///     `new_state` must match the structure of `initial_state`.
+@inlinable @inline(__always)
+public static func reduceDataset<
+    FIn: TensorGroup,
+    FOut: TensorGroup,
+    Tstate: TensorArrayProtocol,
+    Targuments: TensorArrayProtocol,
+    OutputTypes: TensorGroup
+>(
+    inputDataset: VariantHandle,
+    initialState: Tstate,
+    otherArguments: Targuments,
+    f: (FIn) -> FOut,
+    outputShapes: [TensorShape?],
+    useInterOpParallelism: Bool = true
+) -> OutputTypes {
+  let nOutputs = Int(OutputTypes._typeList.count)
+    let op = makeOp("ReduceDataset", nOutputs)
+    op.updateAttribute("f", f)
+    op.updateAttribute("Tstate", initialState._typeList)
+    op.updateAttribute("Targuments", otherArguments._typeList)
+    op.updateAttribute("output_types", OutputTypes._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("use_inter_op_parallelism", useInterOpParallelism)
+    op.addInput(inputDataset)
+    op.addInputList(initialState)
+    op.addInputList(otherArguments)
+    return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Joins a string Tensor across the given dimensions.
+///
+/// Computes the string join across dimensions in the given string Tensor of shape
+/// `[\\(d_0, d_1, ..., d_{n-1}\\)]`.  Returns a new Tensor created by joining the input
+/// strings with the given separator (default: empty string).  Negative indices are
+/// counted backwards from the end, with `-1` being equivalent to `n - 1`.  If
+/// indices are not specified, joins across all dimensions beginning from `n - 1`
+/// through `0`.
+///
+/// For example:
+///
+/// ```python
+/// # tensor `a` is [["a", "b"], ["c", "d"]]
+/// tf.reduce_join(a, 0) ==> ["ac", "bd"]
+/// tf.reduce_join(a, 1) ==> ["ab", "cd"]
+/// tf.reduce_join(a, -2) = tf.reduce_join(a, 0) ==> ["ac", "bd"]
+/// tf.reduce_join(a, -1) = tf.reduce_join(a, 1) ==> ["ab", "cd"]
+/// tf.reduce_join(a, 0, keep_dims=True) ==> [["ac", "bd"]]
+/// tf.reduce_join(a, 1, keep_dims=True) ==> [["ab"], ["cd"]]
+/// tf.reduce_join(a, 0, separator=".") ==> ["a.c", "b.d"]
+/// tf.reduce_join(a, [0, 1]) ==> "acbd"
+/// tf.reduce_join(a, [1, 0]) ==> "abcd"
+/// tf.reduce_join(a, []) ==> [["a", "b"], ["c", "d"]]
+/// tf.reduce_join(a) = tf.reduce_join(a, [1, 0]) ==> "abcd"
+/// ```
+///
+/// - Parameters:
+///     - inputs: The input to be joined.  All reduced indices must have non-zero size.
+///     - reduction_indices: The dimensions to reduce over.  Dimensions are reduced in the
+///         order specified.  Omitting `reduction_indices` is equivalent to passing
+///         `[n-1, n-2, ..., 0]`.  Negative indices from `-n` to `-1` are supported.
+///
+/// - Attrs:
+///     - keep_dims: If `True`, retain reduced dimensions with length `1`.
+///     - separator: The separator to use when joining.
+///
+/// - Output output: Has shape equal to that of the input with reduced dimensions removed or
+///     set to `1` depending on `keep_dims`.
+@inlinable @inline(__always)
+public static func reduceJoin(
+    inputs: StringTensor,
+    reductionIndices: Tensor<Int32>,
+    keepDims: Bool = false,
+    separator: String
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("ReduceJoin", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("separator", separator)
+    op.addInput(inputs)
+    op.addInput(reductionIndices)
+    return op.execute(Int(1))
+}
+
+/// Check if the input matches the regex pattern.
+///
+/// The input is a string tensor of any shape. The pattern is a scalar
+/// string tensor which is applied to every element of the input tensor.
+/// The boolean values (True or False) of the output tensor indicate
+/// if the input matches the regex pattern provided.
+///
+/// The pattern follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
+///
+/// - Parameters:
+///     - input: A string tensor of the text to be processed.
+///     - pattern: A scalar string tensor containing the regular expression to match the input.
+///
+/// - Output output: A bool tensor with the same shape as `input`.
+@inlinable @inline(__always)
+public static func regexFullMatch(
+    _ input: StringTensor,
+    pattern: StringTensor
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("RegexFullMatch", nOutputs)
+    op.addInput(input)
+    op.addInput(pattern)
+    return op.execute(Int(1))
+}
+
+/// Replaces matches of the `pattern` regular expression in `input` with the
+/// replacement string provided in `rewrite`.
+///
+/// It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
+///
+/// - Parameters:
+///     - input: The text to be processed.
+///     - pattern: The regular expression to be matched in the `input` strings.
+///     - rewrite: The rewrite string to be substituted for the `pattern` expression where it is
+///         matched in the `input` strings.
+///
+/// - Attr replace_global: If True, the replacement is global (that is, all matches of the `pattern` regular
+///     expression in each input string are rewritten), otherwise the `rewrite`
+///     substitution is only made for the first `pattern` match.
+///
+/// - Output output: The text after applying pattern match and rewrite substitution.
+@inlinable @inline(__always)
+public static func regexReplace(
+    _ input: StringTensor,
+    pattern: StringTensor,
+    rewrite: StringTensor,
+    replaceGlobal: Bool = true
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("RegexReplace", nOutputs)
+    op.updateAttribute("replace_global", replaceGlobal)
+    op.addInput(input)
+    op.addInput(pattern)
+    op.addInput(rewrite)
+    return op.execute(Int(1))
+}
+
+/// Computes rectified linear: `max(features, 0)`.
+@inlinable @inline(__always)
+public static func relu<T: Numeric & TensorFlowScalar>(
+    features: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Relu", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(features)
+    return op.execute(Int(1))
+}
+
+/// Computes rectified linear 6: `min(max(features, 0), 6)`.
+@inlinable @inline(__always)
+public static func relu6<T: Numeric & TensorFlowScalar>(
+    features: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Relu6", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(features)
+    return op.execute(Int(1))
+}
+
+/// Computes rectified linear 6 gradients for a Relu6 operation.
+///
+/// - Parameters:
+///     - gradients: The backpropagated gradients to the corresponding Relu6 operation.
+///     - features: The features passed as input to the corresponding Relu6 operation, or
+///         its output; using either one produces the same result.
+///
+/// - Output backprops: The gradients:
+///     `gradients * (features > 0) * (features < 6)`.
+@inlinable @inline(__always)
+public static func relu6Grad<T: Numeric & TensorFlowScalar>(
+    gradients: Tensor<T>,
+    features: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Relu6Grad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(gradients)
+    op.addInput(features)
+    return op.execute(Int(1))
+}
+
+/// Computes rectified linear gradients for a Relu operation.
+///
+/// - Parameters:
+///     - gradients: The backpropagated gradients to the corresponding Relu operation.
+///     - features: The features passed as input to the corresponding Relu operation, OR
+///         the outputs of that operation (both work equivalently).
+///
+/// - Output backprops: `gradients * (features > 0)`.
+@inlinable @inline(__always)
+public static func reluGrad<T: Numeric & TensorFlowScalar>(
+    gradients: Tensor<T>,
+    features: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ReluGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(gradients)
+    op.addInput(features)
+    return op.execute(Int(1))
+}
+
+/// Runs function `f` on a remote device indicated by `target`.
+///
+/// - Parameters:
+///     - target: A fully specified device name where we want to run the function.
+///     - args: A list of arguments for the function.
+///
+/// - Attrs:
+///     - Tin: The type list for the arguments.
+///     - Tout: The type list for the return values.
+///     - f: The function to run remotely.
+///
+/// - Output output: A list of return values.
+@inlinable @inline(__always)
+public static func remoteCall<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    FIn: TensorGroup,
+    FOut: TensorGroup
+>(
+    target: StringTensor,
+    args: Tin,
+    f: (FIn) -> FOut
+) -> Tout {
+  let nOutputs = Int(Tout._typeList.count)
+    let op = makeOp("RemoteCall", nOutputs)
+    op.updateAttribute("Tin", args._typeList)
+    op.updateAttribute("Tout", Tout._typeList)
+    op.updateAttribute("f", f)
+    op.addInput(target)
+    op.addInputList(args)
+    return op.execute(Int(Tout._typeList.count))
+}
+
+/// Execute a sub graph on a remote processor.
+///
+/// The graph specifications(such as graph itself, input tensors and output names)
+/// are stored as a serialized protocol buffer of RemoteFusedGraphExecuteInfo
+/// as serialized_remote_fused_graph_execute_info.
+/// The specifications will be passed to a dedicated registered
+/// remote fused graph executor.  The executor will send the graph specifications
+/// to a remote processor and execute that graph.  The execution results
+/// will be passed to consumer nodes as outputs of this node.
+///
+/// - Parameter inputs: Arbitrary number of tensors with arbitrary data types
+///
+/// - Attr serialized_remote_fused_graph_execute_info: Serialized protocol buffer
+///     of RemoteFusedGraphExecuteInfo which contains graph specifications.
+///
+/// - Output outputs: Arbitrary number of tensors with arbitrary data types
+@inlinable @inline(__always)
+public static func remoteFusedGraphExecute<
+    Tinputs: TensorArrayProtocol,
+    Toutputs: TensorGroup
+>(
+    inputs: Tinputs,
+    serializedRemoteFusedGraphExecuteInfo: String
+) -> Toutputs {
+  let nOutputs = Int(Toutputs._typeList.count)
+    let op = makeOp("RemoteFusedGraphExecute", nOutputs)
+    op.updateAttribute("Tinputs", inputs._typeList)
+    op.updateAttribute("Toutputs", Toutputs._typeList)
+    op.updateAttribute("serialized_remote_fused_graph_execute_info", serializedRemoteFusedGraphExecuteInfo)
+    op.addInputList(inputs)
+    return op.execute(Int(Toutputs._typeList.count))
+}
+
+/// Creates a dataset that emits the outputs of `input_dataset` `count` times.
+///
+/// - Parameter count: A scalar representing the number of times that `input_dataset` should
+///     be repeated. A value of `-1` indicates that it should be repeated infinitely.
+@inlinable @inline(__always)
+public static func repeatDataset(
+    inputDataset: VariantHandle,
+    count: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("RepeatDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(count)
+    return op.execute(Int(1))
+}
+
+/// Computes a range that covers the actual values present in a quantized tensor.
+///
+/// Given a quantized tensor described by `(input, input_min, input_max)`, outputs a
+/// range that covers the actual values present in that tensor. This op is typically
+/// used to produce the `requested_output_min` and `requested_output_max` for
+/// `Requantize`.
+///
+/// - Parameters:
+///     - input_min: The float value that the minimum quantized input value represents.
+///     - input_max: The float value that the maximum quantized input value represents.
+///
+/// - Attr Tinput: The type of the input.
+///
+/// - Outputs:
+///     - output_min: The computed min output.
+///     - output_max: the computed max output.
+@inlinable @inline(__always)
+public static func requantizationRange<Tinput: TensorFlowScalar>(
+    _ input: Tensor<Tinput>,
+    inputMin: Tensor<Float>,
+    inputMax: Tensor<Float>
+) -> (outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("RequantizationRange", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(inputMin)
+    op.addInput(inputMax)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Computes requantization range per channel.
+///
+/// - Parameters:
+///     - input: The original input tensor.
+///     - input_min: The minimum value of the input tensor
+///     - input_max: The maximum value of the input tensor.
+///
+/// - Attrs:
+///     - T: The quantized type of input tensor that needs to be converted. 
+///     - clip_value_max: The maximum value of the output that needs to be clipped.
+///         Example: set this to 6 for Relu6. 
+///
+/// - Outputs:
+///     - output_min: The minimum value of the final output tensor
+///     - output_max: The maximum value of the final output tensor.
+@inlinable @inline(__always)
+public static func requantizationRangePerChannel<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    inputMin: Tensor<Float>,
+    inputMax: Tensor<Float>,
+    clipValueMax: Double
+) -> (outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("RequantizationRangePerChannel", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("clip_value_max", clipValueMax)
+    op.addInput(input)
+    op.addInput(inputMin)
+    op.addInput(inputMax)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Converts the quantized `input` tensor into a lower-precision `output`.
+///
+/// Converts the quantized `input` tensor into a lower-precision `output`, using the
+/// output range specified with `requested_output_min` and `requested_output_max`.
+///
+/// `[input_min, input_max]` are scalar floats that specify the range for the float
+/// interpretation of the `input` data. For example, if `input_min` is -1.0f and
+/// `input_max` is 1.0f, and we are dealing with `quint16` quantized data, then a 0
+/// value in the 16-bit data should be interpreted as -1.0f, and a 65535 means 1.0f.
+///
+/// - Parameters:
+///     - input_min: The float value that the minimum quantized input value represents.
+///     - input_max: The float value that the maximum quantized input value represents.
+///     - requested_output_min: The float value that the minimum quantized output value represents.
+///     - requested_output_max: The float value that the maximum quantized output value represents.
+///
+/// - Attrs:
+///     - Tinput: The type of the input.
+///     - out_type: The type of the output. Should be a lower bit depth than Tinput.
+///
+/// - Outputs:
+///     - output_min: The requested_output_min value is copied into this output.
+///     - output_max: The requested_output_max value is copied into this output.
+@inlinable @inline(__always)
+public static func requantize<
+    Tinput: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<Tinput>,
+    inputMin: Tensor<Float>,
+    inputMax: Tensor<Float>,
+    requestedOutputMin: Tensor<Float>,
+    requestedOutputMax: Tensor<Float>
+) -> (output: Tensor<OutType>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("Requantize", nOutputs)
+    op.updateAttribute("Tinput", Tinput.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(inputMin)
+    op.addInput(inputMax)
+    op.addInput(requestedOutputMin)
+    op.addInput(requestedOutputMax)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Requantizes input with min and max values known per channel.
+///
+/// - Parameters:
+///     - input: The original input tensor.
+///     - input_min: The minimum value of the input tensor
+///     - input_max: The maximum value of the input tensor.
+///     - requested_output_min: The minimum value of the output tensor requested.
+///     - requested_output_max: The maximum value of the output tensor requested.
+///
+/// - Attrs:
+///     - T: The quantized type of input tensor that needs to be converted. 
+///     - out_type: The quantized type of output tensor that needs to be converted.
+///
+/// - Outputs:
+///     - output: Output tensor.
+///     - output_min: The minimum value of the final output tensor
+///     - output_max: The maximum value of the final output tensor.
+@inlinable @inline(__always)
+public static func requantizePerChannel<
+    T: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    inputMin: Tensor<Float>,
+    inputMax: Tensor<Float>,
+    requestedOutputMin: Tensor<Float>,
+    requestedOutputMax: Tensor<Float>
+) -> (output: Tensor<OutType>, outputMin: Tensor<Float>, outputMax: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("RequantizePerChannel", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(inputMin)
+    op.addInput(inputMax)
+    op.addInput(requestedOutputMin)
+    op.addInput(requestedOutputMax)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func requiresOlderGraphVersion(
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("RequiresOlderGraphVersion", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func reservedAttr(
+    range: Int64
+) {
+  let nOutputs = 0
+    let op = makeOp("ReservedAttr", nOutputs)
+    op.updateAttribute("range", range)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func reservedInput(
+    _ input: Tensor<Int32>
+) {
+  let nOutputs = 0
+    let op = makeOp("ReservedInput", nOutputs)
+    op.addInput(input)
+    op.execute()
+}
+
+/// Reshapes a tensor.
+///
+/// Given `tensor`, this operation returns a tensor that has the same values
+/// as `tensor` with shape `shape`.
+///
+/// If one component of `shape` is the special value -1, the size of that dimension
+/// is computed so that the total size remains constant.  In particular, a `shape`
+/// of `[-1]` flattens into 1-D.  At most one component of `shape` can be -1.
+///
+/// If `shape` is 1-D or higher, then the operation returns a tensor with shape
+/// `shape` filled with the values of `tensor`. In this case, the number of elements
+/// implied by `shape` must be the same as the number of elements in `tensor`.
+///
+/// For example:
+///
+/// ```
+/// # tensor 't' is [1, 2, 3, 4, 5, 6, 7, 8, 9]
+/// # tensor 't' has shape [9]
+/// reshape(t, [3, 3]) ==> [[1, 2, 3],
+///                         [4, 5, 6],
+///                         [7, 8, 9]]
+///
+/// # tensor 't' is [[[1, 1], [2, 2]],
+/// #                [[3, 3], [4, 4]]]
+/// # tensor 't' has shape [2, 2, 2]
+/// reshape(t, [2, 4]) ==> [[1, 1, 2, 2],
+///                         [3, 3, 4, 4]]
+///
+/// # tensor 't' is [[[1, 1, 1],
+/// #                 [2, 2, 2]],
+/// #                [[3, 3, 3],
+/// #                 [4, 4, 4]],
+/// #                [[5, 5, 5],
+/// #                 [6, 6, 6]]]
+/// # tensor 't' has shape [3, 2, 3]
+/// # pass '[-1]' to flatten 't'
+/// reshape(t, [-1]) ==> [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]
+///
+/// # -1 can also be used to infer the shape
+///
+/// # -1 is inferred to be 9:
+/// reshape(t, [2, -1]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
+///                          [4, 4, 4, 5, 5, 5, 6, 6, 6]]
+/// # -1 is inferred to be 2:
+/// reshape(t, [-1, 9]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3],
+///                          [4, 4, 4, 5, 5, 5, 6, 6, 6]]
+/// # -1 is inferred to be 3:
+/// reshape(t, [ 2, -1, 3]) ==> [[[1, 1, 1],
+///                               [2, 2, 2],
+///                               [3, 3, 3]],
+///                              [[4, 4, 4],
+///                               [5, 5, 5],
+///                               [6, 6, 6]]]
+///
+/// # tensor 't' is [7]
+/// # shape `[]` reshapes to a scalar
+/// reshape(t, []) ==> 7
+/// ```
+///
+/// - Parameter shape: Defines the shape of the output tensor.
+@inlinable @inline(__always)
+public static func reshape<
+    T: TensorFlowScalar,
+    Tshape: BinaryInteger & TensorFlowScalar
+>(
+    _ tensor: Tensor<T>,
+    shape: Tensor<Tshape>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Reshape", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tshape", Tshape.tensorFlowDataType)
+    op.addInput(tensor)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Resize `images` to `size` using area interpolation.
+///
+/// Input images can be of different types but output images are always float.
+///
+/// The range of pixel values for the output image might be slightly different
+/// from the range for the input image because of limited numerical precision.
+/// To guarantee an output range, for example `[0.0, 1.0]`, apply
+/// `tf.clip_by_value` to the output.
+///
+/// Each output pixel is computed by first transforming the pixel's footprint into
+/// the input tensor and then averaging the pixels that intersect the footprint. An
+/// input pixel's contribution to the average is weighted by the fraction of its
+/// area that intersects the footprint.  This is the same as OpenCV's INTER_AREA.
+///
+/// - Parameters:
+///     - images: 4-D with shape `[batch, height, width, channels]`.
+///     - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+///         new size for the images.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
+///     aligned, preserving the values at the corner pixels. Defaults to false.
+///
+/// - Output resized_images: 4-D with shape
+///     `[batch, new_height, new_width, channels]`.
+@inlinable @inline(__always)
+public static func resizeArea<T: Numeric & TensorFlowScalar>(
+    images: Tensor<T>,
+    size: Tensor<Int32>,
+    alignCorners: Bool = false
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("ResizeArea", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("align_corners", alignCorners)
+    op.addInput(images)
+    op.addInput(size)
+    return op.execute(Int(1))
+}
+
+/// Resize `images` to `size` using bicubic interpolation.
+///
+/// Input images can be of different types but output images are always float.
+///
+/// - Parameters:
+///     - images: 4-D with shape `[batch, height, width, channels]`.
+///     - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+///         new size for the images.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
+///     aligned, preserving the values at the corner pixels. Defaults to false.
+///
+/// - Output resized_images: 4-D with shape
+///     `[batch, new_height, new_width, channels]`.
+@inlinable @inline(__always)
+public static func resizeBicubic<T: Numeric & TensorFlowScalar>(
+    images: Tensor<T>,
+    size: Tensor<Int32>,
+    alignCorners: Bool = false,
+    halfPixelCenters: Bool = false
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("ResizeBicubic", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("align_corners", alignCorners)
+    op.updateAttribute("half_pixel_centers", halfPixelCenters)
+    op.addInput(images)
+    op.addInput(size)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient of bicubic interpolation.
+///
+/// - Parameters:
+///     - grads: 4-D with shape `[batch, height, width, channels]`.
+///     - original_image: 4-D with shape `[batch, orig_height, orig_width, channels]`,
+///         The image tensor that was resized.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and grad tensors are
+///     aligned. Defaults to false.
+///
+/// - Output output: 4-D with shape `[batch, orig_height, orig_width, channels]`.
+///     Gradients with respect to the input image. Input image must have been
+///     float or double.
+@inlinable @inline(__always)
+public static func resizeBicubicGrad<T: FloatingPoint & TensorFlowScalar>(
+    grads: Tensor<Float>,
+    originalImage: Tensor<T>,
+    alignCorners: Bool = false,
+    halfPixelCenters: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ResizeBicubicGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("align_corners", alignCorners)
+    op.updateAttribute("half_pixel_centers", halfPixelCenters)
+    op.addInput(grads)
+    op.addInput(originalImage)
+    return op.execute(Int(1))
+}
+
+/// Resize `images` to `size` using bilinear interpolation.
+///
+/// Input images can be of different types but output images are always float.
+///
+/// - Parameters:
+///     - images: 4-D with shape `[batch, height, width, channels]`.
+///     - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+///         new size for the images.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
+///     aligned, preserving the values at the corner pixels. Defaults to false.
+///
+/// - Output resized_images: 4-D with shape
+///     `[batch, new_height, new_width, channels]`.
+@inlinable @inline(__always)
+public static func resizeBilinear<T: Numeric & TensorFlowScalar>(
+    images: Tensor<T>,
+    size: Tensor<Int32>,
+    alignCorners: Bool = false,
+    halfPixelCenters: Bool = false
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("ResizeBilinear", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("align_corners", alignCorners)
+    op.updateAttribute("half_pixel_centers", halfPixelCenters)
+    op.addInput(images)
+    op.addInput(size)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient of bilinear interpolation.
+///
+/// - Parameters:
+///     - grads: 4-D with shape `[batch, height, width, channels]`.
+///     - original_image: 4-D with shape `[batch, orig_height, orig_width, channels]`,
+///         The image tensor that was resized.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and grad tensors are
+///     aligned. Defaults to false.
+///
+/// - Output output: 4-D with shape `[batch, orig_height, orig_width, channels]`.
+///     Gradients with respect to the input image. Input image must have been
+///     float or double.
+@inlinable @inline(__always)
+public static func resizeBilinearGrad<T: FloatingPoint & TensorFlowScalar>(
+    grads: Tensor<Float>,
+    originalImage: Tensor<T>,
+    alignCorners: Bool = false,
+    halfPixelCenters: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ResizeBilinearGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("align_corners", alignCorners)
+    op.updateAttribute("half_pixel_centers", halfPixelCenters)
+    op.addInput(grads)
+    op.addInput(originalImage)
+    return op.execute(Int(1))
+}
+
+/// Resize `images` to `size` using nearest neighbor interpolation.
+///
+/// - Parameters:
+///     - images: 4-D with shape `[batch, height, width, channels]`.
+///     - size: = A 1-D int32 Tensor of 2 elements: `new_height, new_width`.  The
+///         new size for the images.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and output tensors are
+///     aligned, preserving the values at the corner pixels. Defaults to false.
+///
+/// - Output resized_images: 4-D with shape
+///     `[batch, new_height, new_width, channels]`.
+@inlinable @inline(__always)
+public static func resizeNearestNeighbor<T: Numeric & TensorFlowScalar>(
+    images: Tensor<T>,
+    size: Tensor<Int32>,
+    alignCorners: Bool = false,
+    halfPixelCenters: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ResizeNearestNeighbor", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("align_corners", alignCorners)
+    op.updateAttribute("half_pixel_centers", halfPixelCenters)
+    op.addInput(images)
+    op.addInput(size)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient of nearest neighbor interpolation.
+///
+/// - Parameters:
+///     - grads: 4-D with shape `[batch, height, width, channels]`.
+///     - size: = A 1-D int32 Tensor of 2 elements: `orig_height, orig_width`. The
+///         original input size.
+///
+/// - Attr align_corners: If true, the centers of the 4 corner pixels of the input and grad tensors are
+///     aligned. Defaults to false.
+///
+/// - Output output: 4-D with shape `[batch, orig_height, orig_width, channels]`. Gradients
+///     with respect to the input image.
+@inlinable @inline(__always)
+public static func resizeNearestNeighborGrad<T: Numeric & TensorFlowScalar>(
+    grads: Tensor<T>,
+    size: Tensor<Int32>,
+    alignCorners: Bool = false,
+    halfPixelCenters: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ResizeNearestNeighborGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("align_corners", alignCorners)
+    op.updateAttribute("half_pixel_centers", halfPixelCenters)
+    op.addInput(grads)
+    op.addInput(size)
+    return op.execute(Int(1))
+}
+
+/// Update '*var' according to the AdaMax algorithm.
+///
+/// m_t <- beta1 * m_{t-1} + (1 - beta1) * g
+/// v_t <- max(beta2 * v_{t-1}, abs(g))
+/// variable <- variable - learning_rate / (1 - beta1^t) * m_t / (v_t + epsilon)
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - m: Should be from a Variable().
+///     - v: Should be from a Variable().
+///     - beta1_power: Must be a scalar.
+///     - lr: Scaling factor. Must be a scalar.
+///     - beta1: Momentum factor. Must be a scalar.
+///     - beta2: Momentum factor. Must be a scalar.
+///     - epsilon: Ridge term. Must be a scalar.
+///     - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var, m, and v tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceApplyAdaMax<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    m: ResourceHandle,
+    v: ResourceHandle,
+    beta1Power: Tensor<T>,
+    lr: Tensor<T>,
+    beta1: Tensor<T>,
+    beta2: Tensor<T>,
+    epsilon: Tensor<T>,
+    grad: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyAdaMax", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(m)
+    op.addInput(v)
+    op.addInput(beta1Power)
+    op.addInput(lr)
+    op.addInput(beta1)
+    op.addInput(beta2)
+    op.addInput(epsilon)
+    op.addInput(grad)
+    op.execute()
+}
+
+/// Update '*var' according to the adadelta scheme.
+///
+/// accum = rho() * accum + (1 - rho()) * grad.square();
+/// update = (update_accum + epsilon).sqrt() * (accum + epsilon()).rsqrt() * grad;
+/// update_accum = rho() * update_accum + (1 - rho()) * update.square();
+/// var -= update;
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - accum_update: Should be from a Variable().
+///     - lr: Scaling factor. Must be a scalar.
+///     - rho: Decay factor. Must be a scalar.
+///     - epsilon: Constant factor. Must be a scalar.
+///     - grad: The gradient.
+///
+/// - Attr use_locking: If True, updating of the var, accum and update_accum tensors will be protected by
+///     a lock; otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceApplyAdadelta<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    accumUpdate: ResourceHandle,
+    lr: Tensor<T>,
+    rho: Tensor<T>,
+    epsilon: Tensor<T>,
+    grad: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyAdadelta", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(accumUpdate)
+    op.addInput(lr)
+    op.addInput(rho)
+    op.addInput(epsilon)
+    op.addInput(grad)
+    op.execute()
+}
+
+/// Update '*var' according to the adagrad scheme.
+///
+/// accum += grad * grad
+/// var -= lr * grad * (1 / sqrt(accum))
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - lr: Scaling factor. Must be a scalar.
+///     - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceApplyAdagrad<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    lr: Tensor<T>,
+    grad: Tensor<T>,
+    useLocking: Bool = false,
+    updateSlots: Bool = true
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyAdagrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.updateAttribute("update_slots", updateSlots)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(lr)
+    op.addInput(grad)
+    op.execute()
+}
+
+/// Update '*var' according to the proximal adagrad scheme.
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - gradient_accumulator: Should be from a Variable().
+///     - gradient_squared_accumulator: Should be from a Variable().
+///     - grad: The gradient.
+///     - lr: Scaling factor. Must be a scalar.
+///     - l1: L1 regularization. Must be a scalar.
+///     - l2: L2 regularization. Must be a scalar.
+///     - global_step: Training step number. Must be a scalar.
+///
+/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
+///     a lock; otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceApplyAdagradDA<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    gradientAccumulator: ResourceHandle,
+    gradientSquaredAccumulator: ResourceHandle,
+    grad: Tensor<T>,
+    lr: Tensor<T>,
+    l1: Tensor<T>,
+    l2: Tensor<T>,
+    globalStep: Tensor<Int64>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyAdagradDA", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(gradientAccumulator)
+    op.addInput(gradientSquaredAccumulator)
+    op.addInput(grad)
+    op.addInput(lr)
+    op.addInput(l1)
+    op.addInput(l2)
+    op.addInput(globalStep)
+    op.execute()
+}
+
+/// Update '*var' according to the Adam algorithm.
+///
+/// $$lr_t := \text{learning\_rate} * \sqrt{1 - beta_2^t} / (1 - beta_1^t)$$
+/// $$m_t := beta_1 * m_{t-1} + (1 - beta_1) * g$$
+/// $$v_t := beta_2 * v_{t-1} + (1 - beta_2) * g * g$$
+/// $$variable := variable - lr_t * m_t / (\sqrt{v_t} + \epsilon)$$
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - m: Should be from a Variable().
+///     - v: Should be from a Variable().
+///     - beta1_power: Must be a scalar.
+///     - beta2_power: Must be a scalar.
+///     - lr: Scaling factor. Must be a scalar.
+///     - beta1: Momentum factor. Must be a scalar.
+///     - beta2: Momentum factor. Must be a scalar.
+///     - epsilon: Ridge term. Must be a scalar.
+///     - grad: The gradient.
+///
+/// - Attrs:
+///     - use_locking: If `True`, updating of the var, m, and v tensors will be protected
+///         by a lock; otherwise the behavior is undefined, but may exhibit less
+///         contention.
+///     - use_nesterov: If `True`, uses the nesterov update.
+@inlinable @inline(__always)
+public static func resourceApplyAdam<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    m: ResourceHandle,
+    v: ResourceHandle,
+    beta1Power: Tensor<T>,
+    beta2Power: Tensor<T>,
+    lr: Tensor<T>,
+    beta1: Tensor<T>,
+    beta2: Tensor<T>,
+    epsilon: Tensor<T>,
+    grad: Tensor<T>,
+    useLocking: Bool = false,
+    useNesterov: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyAdam", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.updateAttribute("use_nesterov", useNesterov)
+    op.addInput(var_)
+    op.addInput(m)
+    op.addInput(v)
+    op.addInput(beta1Power)
+    op.addInput(beta2Power)
+    op.addInput(lr)
+    op.addInput(beta1)
+    op.addInput(beta2)
+    op.addInput(epsilon)
+    op.addInput(grad)
+    op.execute()
+}
+
+/// Update '*var' according to the Adam algorithm.
+///
+/// $$lr_t := \text{learning\_rate} * \sqrt{1 - beta_2^t} / (1 - beta_1^t)$$
+/// $$m_t := beta_1 * m_{t-1} + (1 - beta_1) * g$$
+/// $$v_t := beta_2 * v_{t-1} + (1 - beta_2) * g * g$$
+/// $$vhat_t := max{vhat_{t-1}, v_t}$$
+/// $$variable := variable - lr_t * m_t / (\sqrt{vhat_t} + \epsilon)$$
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - m: Should be from a Variable().
+///     - v: Should be from a Variable().
+///     - vhat: Should be from a Variable().
+///     - beta1_power: Must be a scalar.
+///     - beta2_power: Must be a scalar.
+///     - lr: Scaling factor. Must be a scalar.
+///     - beta1: Momentum factor. Must be a scalar.
+///     - beta2: Momentum factor. Must be a scalar.
+///     - epsilon: Ridge term. Must be a scalar.
+///     - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var, m, and v tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceApplyAdamWithAmsgrad<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    m: ResourceHandle,
+    v: ResourceHandle,
+    vhat: ResourceHandle,
+    beta1Power: Tensor<T>,
+    beta2Power: Tensor<T>,
+    lr: Tensor<T>,
+    beta1: Tensor<T>,
+    beta2: Tensor<T>,
+    epsilon: Tensor<T>,
+    grad: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyAdamWithAmsgrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(m)
+    op.addInput(v)
+    op.addInput(vhat)
+    op.addInput(beta1Power)
+    op.addInput(beta2Power)
+    op.addInput(lr)
+    op.addInput(beta1)
+    op.addInput(beta2)
+    op.addInput(epsilon)
+    op.addInput(grad)
+    op.execute()
+}
+
+/// Update '*var' according to the AddSign update.
+///
+/// m_t <- beta1 * m_{t-1} + (1 - beta1) * g
+/// update <- (alpha + sign_decay * sign(g) *sign(m)) * g
+/// variable <- variable - lr_t * update
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - m: Should be from a Variable().
+///     - lr: Scaling factor. Must be a scalar.
+///     - alpha: Must be a scalar.
+///     - sign_decay: Must be a scalar.
+///     - beta: Must be a scalar.
+///     - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var and m tensors is
+///     protected by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceApplyAddSign<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    m: ResourceHandle,
+    lr: Tensor<T>,
+    alpha: Tensor<T>,
+    signDecay: Tensor<T>,
+    beta: Tensor<T>,
+    grad: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyAddSign", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(m)
+    op.addInput(lr)
+    op.addInput(alpha)
+    op.addInput(signDecay)
+    op.addInput(beta)
+    op.addInput(grad)
+    op.execute()
+}
+
+/// Update '*var' according to the centered RMSProp algorithm.
+///
+/// The centered RMSProp algorithm uses an estimate of the centered second moment
+/// (i.e., the variance) for normalization, as opposed to regular RMSProp, which
+/// uses the (uncentered) second moment. This often helps with training, but is
+/// slightly more expensive in terms of computation and memory.
+///
+/// Note that in dense implementation of this algorithm, mg, ms, and mom will
+/// update even if the grad is zero, but in this sparse implementation, mg, ms,
+/// and mom will not update in iterations during which the grad is zero.
+///
+/// mean_square = decay * mean_square + (1-decay) * gradient ** 2
+/// mean_grad = decay * mean_grad + (1-decay) * gradient
+///
+/// Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
+///
+/// mg <- rho * mg_{t-1} + (1-rho) * grad
+/// ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+/// mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms - mg * mg + epsilon)
+/// var <- var - mom
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - mg: Should be from a Variable().
+///     - ms: Should be from a Variable().
+///     - mom: Should be from a Variable().
+///     - lr: Scaling factor. Must be a scalar.
+///     - rho: Decay rate. Must be a scalar.
+///     - epsilon: Ridge term. Must be a scalar.
+///     - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var, mg, ms, and mom tensors is
+///     protected by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceApplyCenteredRMSProp<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    mg: ResourceHandle,
+    ms: ResourceHandle,
+    mom: ResourceHandle,
+    lr: Tensor<T>,
+    rho: Tensor<T>,
+    momentum: Tensor<T>,
+    epsilon: Tensor<T>,
+    grad: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyCenteredRMSProp", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(mg)
+    op.addInput(ms)
+    op.addInput(mom)
+    op.addInput(lr)
+    op.addInput(rho)
+    op.addInput(momentum)
+    op.addInput(epsilon)
+    op.addInput(grad)
+    op.execute()
+}
+
+/// Update '*var' according to the Ftrl-proximal scheme.
+///
+/// accum_new = accum + grad * grad
+/// linear += grad - (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+/// quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+/// var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+/// accum = accum_new
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - linear: Should be from a Variable().
+///     - grad: The gradient.
+///     - lr: Scaling factor. Must be a scalar.
+///     - l1: L1 regulariation. Must be a scalar.
+///     - l2: L2 regulariation. Must be a scalar.
+///     - lr_power: Scaling factor. Must be a scalar.
+///
+/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceApplyFtrl<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    linear: ResourceHandle,
+    grad: Tensor<T>,
+    lr: Tensor<T>,
+    l1: Tensor<T>,
+    l2: Tensor<T>,
+    lrPower: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyFtrl", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(linear)
+    op.addInput(grad)
+    op.addInput(lr)
+    op.addInput(l1)
+    op.addInput(l2)
+    op.addInput(lrPower)
+    op.execute()
+}
+
+/// Update '*var' according to the Ftrl-proximal scheme.
+///
+/// grad_with_shrinkage = grad + 2 * l2_shrinkage * var
+/// accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
+/// linear += grad_with_shrinkage +
+///     (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+/// quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+/// var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+/// accum = accum_new
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - linear: Should be from a Variable().
+///     - grad: The gradient.
+///     - lr: Scaling factor. Must be a scalar.
+///     - l1: L1 regulariation. Must be a scalar.
+///     - l2: L2 shrinkage regulariation. Must be a scalar.
+///     - lr_power: Scaling factor. Must be a scalar.
+///
+/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceApplyFtrlV2<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    linear: ResourceHandle,
+    grad: Tensor<T>,
+    lr: Tensor<T>,
+    l1: Tensor<T>,
+    l2: Tensor<T>,
+    l2Shrinkage: Tensor<T>,
+    lrPower: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyFtrlV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(linear)
+    op.addInput(grad)
+    op.addInput(lr)
+    op.addInput(l1)
+    op.addInput(l2)
+    op.addInput(l2Shrinkage)
+    op.addInput(lrPower)
+    op.execute()
+}
+
+/// Update '*var' by subtracting 'alpha' * 'delta' from it.
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - alpha: Scaling factor. Must be a scalar.
+///     - delta: The change.
+///
+/// - Attr use_locking: If `True`, the subtraction will be protected by a lock;
+///     otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceApplyGradientDescent<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    alpha: Tensor<T>,
+    delta: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyGradientDescent", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(alpha)
+    op.addInput(delta)
+    op.execute()
+}
+
+/// Update '*var' according to the momentum scheme. Set use_nesterov = True if you
+///
+/// want to use Nesterov momentum.
+///
+/// accum = accum * momentum - lr * grad
+/// var += accum
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - lr: Scaling factor. Must be a scalar.
+///     - grad: The gradient.
+///     - momentum: Momentum. Must be a scalar.
+///
+/// - Attrs:
+///     - use_locking: If `True`, updating of the var and accum tensors will be protected
+///         by a lock; otherwise the behavior is undefined, but may exhibit less
+///         contention.
+///     - use_nesterov: If `True`, the tensor passed to compute grad will be
+///         var + momentum * accum, so in the end, the var you get is actually
+///         var + momentum * accum.
+@inlinable @inline(__always)
+public static func resourceApplyKerasMomentum<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    lr: Tensor<T>,
+    grad: Tensor<T>,
+    momentum: Tensor<T>,
+    useLocking: Bool = false,
+    useNesterov: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyKerasMomentum", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.updateAttribute("use_nesterov", useNesterov)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(lr)
+    op.addInput(grad)
+    op.addInput(momentum)
+    op.execute()
+}
+
+/// Update '*var' according to the momentum scheme. Set use_nesterov = True if you
+///
+/// want to use Nesterov momentum.
+///
+/// accum = accum * momentum + grad
+/// var -= lr * accum
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - lr: Scaling factor. Must be a scalar.
+///     - grad: The gradient.
+///     - momentum: Momentum. Must be a scalar.
+///
+/// - Attrs:
+///     - use_locking: If `True`, updating of the var and accum tensors will be protected
+///         by a lock; otherwise the behavior is undefined, but may exhibit less
+///         contention.
+///     - use_nesterov: If `True`, the tensor passed to compute grad will be
+///         var - lr * momentum * accum, so in the end, the var you get is actually
+///         var - lr * momentum * accum.
+@inlinable @inline(__always)
+public static func resourceApplyMomentum<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    lr: Tensor<T>,
+    grad: Tensor<T>,
+    momentum: Tensor<T>,
+    useLocking: Bool = false,
+    useNesterov: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyMomentum", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.updateAttribute("use_nesterov", useNesterov)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(lr)
+    op.addInput(grad)
+    op.addInput(momentum)
+    op.execute()
+}
+
+/// Update '*var' according to the AddSign update.
+///
+/// m_t <- beta1 * m_{t-1} + (1 - beta1) * g
+/// update <- exp(logbase * sign_decay * sign(g) * sign(m_t)) * g
+/// variable <- variable - lr_t * update
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - m: Should be from a Variable().
+///     - lr: Scaling factor. Must be a scalar.
+///     - logbase: Must be a scalar.
+///     - sign_decay: Must be a scalar.
+///     - beta: Must be a scalar.
+///     - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var and m tensors is
+///     protected by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceApplyPowerSign<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    m: ResourceHandle,
+    lr: Tensor<T>,
+    logbase: Tensor<T>,
+    signDecay: Tensor<T>,
+    beta: Tensor<T>,
+    grad: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyPowerSign", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(m)
+    op.addInput(lr)
+    op.addInput(logbase)
+    op.addInput(signDecay)
+    op.addInput(beta)
+    op.addInput(grad)
+    op.execute()
+}
+
+/// Update '*var' and '*accum' according to FOBOS with Adagrad learning rate.
+///
+/// accum += grad * grad
+/// prox_v = var - lr * grad * (1 / sqrt(accum))
+/// var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - lr: Scaling factor. Must be a scalar.
+///     - l1: L1 regularization. Must be a scalar.
+///     - l2: L2 regularization. Must be a scalar.
+///     - grad: The gradient.
+///
+/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
+///     a lock; otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceApplyProximalAdagrad<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    lr: Tensor<T>,
+    l1: Tensor<T>,
+    l2: Tensor<T>,
+    grad: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyProximalAdagrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(lr)
+    op.addInput(l1)
+    op.addInput(l2)
+    op.addInput(grad)
+    op.execute()
+}
+
+/// Update '*var' as FOBOS algorithm with fixed learning rate.
+///
+/// prox_v = var - alpha * delta
+/// var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - alpha: Scaling factor. Must be a scalar.
+///     - l1: L1 regularization. Must be a scalar.
+///     - l2: L2 regularization. Must be a scalar.
+///     - delta: The change.
+///
+/// - Attr use_locking: If True, the subtraction will be protected by a lock;
+///     otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceApplyProximalGradientDescent<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    alpha: Tensor<T>,
+    l1: Tensor<T>,
+    l2: Tensor<T>,
+    delta: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyProximalGradientDescent", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(alpha)
+    op.addInput(l1)
+    op.addInput(l2)
+    op.addInput(delta)
+    op.execute()
+}
+
+/// Update '*var' according to the RMSProp algorithm.
+///
+/// Note that in dense implementation of this algorithm, ms and mom will
+/// update even if the grad is zero, but in this sparse implementation, ms
+/// and mom will not update in iterations during which the grad is zero.
+///
+/// mean_square = decay * mean_square + (1-decay) * gradient ** 2
+/// Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
+///
+/// ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+/// mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
+/// var <- var - mom
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - ms: Should be from a Variable().
+///     - mom: Should be from a Variable().
+///     - lr: Scaling factor. Must be a scalar.
+///     - rho: Decay rate. Must be a scalar.
+///     - epsilon: Ridge term. Must be a scalar.
+///     - grad: The gradient.
+///
+/// - Attr use_locking: If `True`, updating of the var, ms, and mom tensors is protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceApplyRMSProp<T: Numeric & TensorFlowScalar>(
+    var_: ResourceHandle,
+    ms: ResourceHandle,
+    mom: ResourceHandle,
+    lr: Tensor<T>,
+    rho: Tensor<T>,
+    momentum: Tensor<T>,
+    epsilon: Tensor<T>,
+    grad: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceApplyRMSProp", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(ms)
+    op.addInput(mom)
+    op.addInput(lr)
+    op.addInput(rho)
+    op.addInput(momentum)
+    op.addInput(epsilon)
+    op.addInput(grad)
+    op.execute()
+}
+
+/// Increments variable pointed to by 'resource' until it reaches 'limit'.
+///
+/// - Parameter resource: Should be from a scalar `Variable` node.
+///
+/// - Attr limit: If incrementing ref would bring it above limit, instead generates an
+///     'OutOfRange' error.
+///
+/// - Output output: A copy of the input before increment. If nothing else modifies the
+///     input, the values produced will all be distinct.
+@inlinable @inline(__always)
+public static func resourceCountUpTo<T: BinaryInteger & TensorFlowScalar>(
+    resource: ResourceHandle,
+    limit: Int64
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ResourceCountUpTo", nOutputs)
+    op.updateAttribute("limit", limit)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(resource)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func resourceCreateOp(
+    resource: ResourceHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceCreateOp", nOutputs)
+    op.addInput(resource)
+    op.execute()
+}
+
+/// Gather slices from the variable pointed to by `resource` according to `indices`.
+///
+/// `indices` must be an integer tensor of any dimension (usually 0-D or 1-D).
+/// Produces an output tensor with shape `indices.shape + params.shape[1:]` where:
+///
+/// ```python
+///     # Scalar indices
+///     output[:, ..., :] = params[indices, :, ... :]
+///
+///     # Vector indices
+///     output[i, :, ..., :] = params[indices[i], :, ... :]
+///
+///     # Higher rank indices
+///     output[i, ..., j, :, ... :] = params[indices[i, ..., j], :, ..., :]
+/// ```
+@inlinable @inline(__always)
+public static func resourceGather<
+    Dtype: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    indices: Tensor<Tindices>,
+    batchDims: Int64 = 0,
+    validateIndices: Bool = true
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("ResourceGather", nOutputs)
+    op.updateAttribute("batch_dims", batchDims)
+    op.updateAttribute("validate_indices", validateIndices)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(indices)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func resourceGatherNd<
+    Dtype: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    indices: Tensor<Tindices>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("ResourceGatherNd", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(indices)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func resourceInitializedOp(
+    resource: ResourceHandle
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("ResourceInitializedOp", nOutputs)
+    op.addInput(resource)
+    return op.execute(Int(1))
+}
+
+/// Adds sparse updates to the variable referenced by `resource`.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] += updates[...]
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] += updates[i, ...]
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions add.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+/// </div>
+///
+/// - Parameters:
+///     - resource: Should be from a `Variable` node.
+///     - indices: A tensor of indices into the first dimension of `ref`.
+///     - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterAdd<
+    Dtype: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    indices: Tensor<Tindices>,
+    updates: Tensor<Dtype>
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceScatterAdd", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(indices)
+    op.addInput(updates)
+    op.execute()
+}
+
+/// Divides sparse updates into the variable referenced by `resource`.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] /= updates[...]
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] /= updates[i, ...]
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] /= updates[i, ..., j, ...]
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions multiply.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+/// </div>
+///
+/// - Parameters:
+///     - resource: Should be from a `Variable` node.
+///     - indices: A tensor of indices into the first dimension of `ref`.
+///     - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterDiv<
+    Dtype: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    indices: Tensor<Tindices>,
+    updates: Tensor<Dtype>
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceScatterDiv", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(indices)
+    op.addInput(updates)
+    op.execute()
+}
+
+/// Reduces sparse updates into the variable referenced by `resource` using the `max` operation.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] = max(ref[indices, ...], updates[...])
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] = max(ref[indices[i], ...], updates[i, ...])
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] = max(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions are combined.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+/// </div>
+///
+/// - Parameters:
+///     - resource: Should be from a `Variable` node.
+///     - indices: A tensor of indices into the first dimension of `ref`.
+///     - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterMax<
+    Dtype: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    indices: Tensor<Tindices>,
+    updates: Tensor<Dtype>
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceScatterMax", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(indices)
+    op.addInput(updates)
+    op.execute()
+}
+
+/// Reduces sparse updates into the variable referenced by `resource` using the `min` operation.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] = min(ref[indices, ...], updates[...])
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] = min(ref[indices[i], ...], updates[i, ...])
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] = min(ref[indices[i, ..., j], ...], updates[i, ..., j, ...])
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions are combined.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+/// </div>
+///
+/// - Parameters:
+///     - resource: Should be from a `Variable` node.
+///     - indices: A tensor of indices into the first dimension of `ref`.
+///     - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterMin<
+    Dtype: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    indices: Tensor<Tindices>,
+    updates: Tensor<Dtype>
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceScatterMin", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(indices)
+    op.addInput(updates)
+    op.execute()
+}
+
+/// Multiplies sparse updates into the variable referenced by `resource`.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] *= updates[...]
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] *= updates[i, ...]
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] *= updates[i, ..., j, ...]
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions multiply.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+/// </div>
+///
+/// - Parameters:
+///     - resource: Should be from a `Variable` node.
+///     - indices: A tensor of indices into the first dimension of `ref`.
+///     - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterMul<
+    Dtype: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    indices: Tensor<Tindices>,
+    updates: Tensor<Dtype>
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceScatterMul", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(indices)
+    op.addInput(updates)
+    op.execute()
+}
+
+/// Applies sparse addition to individual values or slices in a Variable.
+///
+/// `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+///
+/// `indices` must be integer tensor, containing indices into `ref`.
+/// It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+///
+/// The innermost dimension of `indices` (with length `K`) corresponds to
+/// indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
+/// dimension of `ref`.
+///
+/// `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+///
+/// ```
+/// [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
+/// ```
+///
+/// For example, say we want to add 4 scattered elements to a rank-1 tensor to
+/// 8 elements. In Python, that addition would look like this:
+///
+/// ```python
+/// ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8], use_resource=True)
+/// indices = tf.constant([[4], [3], [1], [7]])
+/// updates = tf.constant([9, 10, 11, 12])
+/// add = tf.scatter_nd_add(ref, indices, updates)
+/// with tf.Session() as sess:
+///   print sess.run(add)
+/// ```
+///
+/// The resulting update to ref would look like this:
+///
+///     [1, 13, 3, 14, 14, 6, 7, 20]
+///
+/// See `tf.scatter_nd` for more details about how to make updates to
+/// slices.
+///
+/// - Parameters:
+///     - ref: A resource handle. Must be from a VarHandleOp.
+///     - indices: A Tensor. Must be one of the following types: int32, int64.
+///         A tensor of indices into ref.
+///     - updates: A Tensor. Must have the same type as ref. A tensor of
+///         values to add to ref.
+///
+/// - Attr use_locking: An optional bool. Defaults to True. If True, the assignment will
+///     be protected by a lock; otherwise the behavior is undefined,
+///     but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceScatterNdAdd<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    ref: ResourceHandle,
+    indices: Tensor<Tindices>,
+    updates: Tensor<T>,
+    useLocking: Bool = true
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceScatterNdAdd", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(ref)
+    op.addInput(indices)
+    op.addInput(updates)
+    op.execute()
+}
+
+/// Applies sparse subtraction to individual values or slices in a Variable.
+///
+/// `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+///
+/// `indices` must be integer tensor, containing indices into `ref`.
+/// It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+///
+/// The innermost dimension of `indices` (with length `K`) corresponds to
+/// indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
+/// dimension of `ref`.
+///
+/// `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+///
+/// ```
+/// [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]]
+/// ```
+///
+/// For example, say we want to subtract 4 scattered elements from a rank-1 tensor
+/// with 8 elements. In Python, that subtraction would look like this:
+///
+/// ```python
+/// ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8], use_resource=True)
+/// indices = tf.constant([[4], [3], [1], [7]])
+/// updates = tf.constant([9, 10, 11, 12])
+/// sub = tf.scatter_nd_sub(ref, indices, updates)
+/// with tf.Session() as sess:
+///   print sess.run(sub)
+/// ```
+///
+/// The resulting update to ref would look like this:
+///
+///     [1, -9, 3, -6, -4, 6, 7, -4]
+///
+/// See `tf.scatter_nd` for more details about how to make updates to
+/// slices.
+///
+/// - Parameters:
+///     - ref: A resource handle. Must be from a VarHandleOp.
+///     - indices: A Tensor. Must be one of the following types: int32, int64.
+///         A tensor of indices into ref.
+///     - updates: A Tensor. Must have the same type as ref. A tensor of
+///         values to add to ref.
+///
+/// - Attr use_locking: An optional bool. Defaults to True. If True, the assignment will
+///     be protected by a lock; otherwise the behavior is undefined,
+///     but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceScatterNdSub<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    ref: ResourceHandle,
+    indices: Tensor<Tindices>,
+    updates: Tensor<T>,
+    useLocking: Bool = true
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceScatterNdSub", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(ref)
+    op.addInput(indices)
+    op.addInput(updates)
+    op.execute()
+}
+
+/// Applies sparse `updates` to individual values or slices within a given
+///
+/// variable according to `indices`.
+///
+/// `ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+///
+/// `indices` must be integer tensor, containing indices into `ref`.
+/// It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
+///
+/// The innermost dimension of `indices` (with length `K`) corresponds to
+/// indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
+/// dimension of `ref`.
+///
+/// `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+///
+/// ```
+/// [d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
+/// ```
+///
+/// For example, say we want to update 4 scattered elements to a rank-1 tensor to
+/// 8 elements. In Python, that update would look like this:
+///
+/// ```python
+///     ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
+///     indices = tf.constant([[4], [3], [1] ,[7]])
+///     updates = tf.constant([9, 10, 11, 12])
+///     update = tf.scatter_nd_update(ref, indices, updates)
+///     with tf.Session() as sess:
+///       print sess.run(update)
+/// ```
+///
+/// The resulting update to ref would look like this:
+///
+///     [1, 11, 3, 10, 9, 6, 7, 12]
+///
+/// See `tf.scatter_nd` for more details about how to make updates to
+/// slices.
+///
+/// - Parameters:
+///     - ref: A resource handle. Must be from a VarHandleOp.
+///     - indices: A Tensor. Must be one of the following types: int32, int64.
+///         A tensor of indices into ref.
+///     - updates: A Tensor. Must have the same type as ref. A tensor of updated
+///         values to add to ref.
+///
+/// - Attr use_locking: An optional bool. Defaults to True. If True, the assignment will
+///     be protected by a lock; otherwise the behavior is undefined,
+///     but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceScatterNdUpdate<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    ref: ResourceHandle,
+    indices: Tensor<Tindices>,
+    updates: Tensor<T>,
+    useLocking: Bool = true
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceScatterNdUpdate", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(ref)
+    op.addInput(indices)
+    op.addInput(updates)
+    op.execute()
+}
+
+/// Subtracts sparse updates from the variable referenced by `resource`.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] -= updates[...]
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] -= updates[i, ...]
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] -= updates[i, ..., j, ...]
+///
+/// Duplicate entries are handled correctly: if multiple `indices` reference
+/// the same location, their contributions add.
+///
+/// Requires `updates.shape = indices.shape + ref.shape[1:]` or `updates.shape = []`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src='https://www.tensorflow.org/images/ScatterAdd.png' alt>
+/// </div>
+///
+/// - Parameters:
+///     - resource: Should be from a `Variable` node.
+///     - indices: A tensor of indices into the first dimension of `ref`.
+///     - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterSub<
+    Dtype: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    indices: Tensor<Tindices>,
+    updates: Tensor<Dtype>
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceScatterSub", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(indices)
+    op.addInput(updates)
+    op.execute()
+}
+
+/// Assigns sparse updates to the variable referenced by `resource`.
+///
+/// This operation computes
+///
+///     # Scalar indices
+///     ref[indices, ...] = updates[...]
+///
+///     # Vector indices (for each i)
+///     ref[indices[i], ...] = updates[i, ...]
+///
+///     # High rank indices (for each i, ..., j)
+///     ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]
+///
+/// - Parameters:
+///     - resource: Should be from a `Variable` node.
+///     - indices: A tensor of indices into the first dimension of `ref`.
+///     - updates: A tensor of updated values to add to `ref`.
+@inlinable @inline(__always)
+public static func resourceScatterUpdate<
+    Dtype: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    indices: Tensor<Tindices>,
+    updates: Tensor<Dtype>
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceScatterUpdate", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(indices)
+    op.addInput(updates)
+    op.execute()
+}
+
+/// var: Should be from a Variable().
+///
+/// - Parameters:
+///     - accum: Should be from a Variable().
+///     - accum_update: : Should be from a Variable().
+///     - lr: Learning rate. Must be a scalar.
+///     - rho: Decay factor. Must be a scalar.
+///     - epsilon: Constant factor. Must be a scalar.
+///     - grad: The gradient.
+///     - indices: A vector of indices into the first dimension of var and accum.
+///
+/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
+///     a lock; otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyAdadelta<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    accumUpdate: ResourceHandle,
+    lr: Tensor<T>,
+    rho: Tensor<T>,
+    epsilon: Tensor<T>,
+    grad: Tensor<T>,
+    indices: Tensor<Tindices>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceSparseApplyAdadelta", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(accumUpdate)
+    op.addInput(lr)
+    op.addInput(rho)
+    op.addInput(epsilon)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.execute()
+}
+
+/// Update relevant entries in '*var' and '*accum' according to the adagrad scheme.
+///
+/// That is for rows we have grad for, we update var and accum as follows:
+/// accum += grad * grad
+/// var -= lr * grad * (1 / sqrt(accum))
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - lr: Learning rate. Must be a scalar.
+///     - grad: The gradient.
+///     - indices: A vector of indices into the first dimension of var and accum.
+///
+/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyAdagrad<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    lr: Tensor<T>,
+    grad: Tensor<T>,
+    indices: Tensor<Tindices>,
+    useLocking: Bool = false,
+    updateSlots: Bool = true
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceSparseApplyAdagrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.updateAttribute("update_slots", updateSlots)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(lr)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.execute()
+}
+
+/// Update entries in '*var' and '*accum' according to the proximal adagrad scheme.
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - gradient_accumulator: Should be from a Variable().
+///     - gradient_squared_accumulator: Should be from a Variable().
+///     - grad: The gradient.
+///     - indices: A vector of indices into the first dimension of var and accum.
+///     - lr: Learning rate. Must be a scalar.
+///     - l1: L1 regularization. Must be a scalar.
+///     - l2: L2 regularization. Must be a scalar.
+///     - global_step: Training step number. Must be a scalar.
+///
+/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
+///     a lock; otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyAdagradDA<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    var_: ResourceHandle,
+    gradientAccumulator: ResourceHandle,
+    gradientSquaredAccumulator: ResourceHandle,
+    grad: Tensor<T>,
+    indices: Tensor<Tindices>,
+    lr: Tensor<T>,
+    l1: Tensor<T>,
+    l2: Tensor<T>,
+    globalStep: Tensor<Int64>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceSparseApplyAdagradDA", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(gradientAccumulator)
+    op.addInput(gradientSquaredAccumulator)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.addInput(lr)
+    op.addInput(l1)
+    op.addInput(l2)
+    op.addInput(globalStep)
+    op.execute()
+}
+
+/// Update '*var' according to the centered RMSProp algorithm.
+///
+/// The centered RMSProp algorithm uses an estimate of the centered second moment
+/// (i.e., the variance) for normalization, as opposed to regular RMSProp, which
+/// uses the (uncentered) second moment. This often helps with training, but is
+/// slightly more expensive in terms of computation and memory.
+///
+/// Note that in dense implementation of this algorithm, mg, ms, and mom will
+/// update even if the grad is zero, but in this sparse implementation, mg, ms,
+/// and mom will not update in iterations during which the grad is zero.
+///
+/// mean_square = decay * mean_square + (1-decay) * gradient ** 2
+/// mean_grad = decay * mean_grad + (1-decay) * gradient
+/// Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2)
+///
+/// ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+/// mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
+/// var <- var - mom
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - mg: Should be from a Variable().
+///     - ms: Should be from a Variable().
+///     - mom: Should be from a Variable().
+///     - lr: Scaling factor. Must be a scalar.
+///     - rho: Decay rate. Must be a scalar.
+///     - epsilon: Ridge term. Must be a scalar.
+///     - grad: The gradient.
+///     - indices: A vector of indices into the first dimension of var, ms and mom.
+///
+/// - Attr use_locking: If `True`, updating of the var, mg, ms, and mom tensors is
+///     protected by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyCenteredRMSProp<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    var_: ResourceHandle,
+    mg: ResourceHandle,
+    ms: ResourceHandle,
+    mom: ResourceHandle,
+    lr: Tensor<T>,
+    rho: Tensor<T>,
+    momentum: Tensor<T>,
+    epsilon: Tensor<T>,
+    grad: Tensor<T>,
+    indices: Tensor<Tindices>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceSparseApplyCenteredRMSProp", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(mg)
+    op.addInput(ms)
+    op.addInput(mom)
+    op.addInput(lr)
+    op.addInput(rho)
+    op.addInput(momentum)
+    op.addInput(epsilon)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.execute()
+}
+
+/// Update relevant entries in '*var' according to the Ftrl-proximal scheme.
+///
+/// That is for rows we have grad for, we update var, accum and linear as follows:
+/// accum_new = accum + grad * grad
+/// linear += grad + (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+/// quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+/// var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+/// accum = accum_new
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - linear: Should be from a Variable().
+///     - grad: The gradient.
+///     - indices: A vector of indices into the first dimension of var and accum.
+///     - lr: Scaling factor. Must be a scalar.
+///     - l1: L1 regularization. Must be a scalar.
+///     - l2: L2 regularization. Must be a scalar.
+///     - lr_power: Scaling factor. Must be a scalar.
+///
+/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyFtrl<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    linear: ResourceHandle,
+    grad: Tensor<T>,
+    indices: Tensor<Tindices>,
+    lr: Tensor<T>,
+    l1: Tensor<T>,
+    l2: Tensor<T>,
+    lrPower: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceSparseApplyFtrl", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(linear)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.addInput(lr)
+    op.addInput(l1)
+    op.addInput(l2)
+    op.addInput(lrPower)
+    op.execute()
+}
+
+/// Update relevant entries in '*var' according to the Ftrl-proximal scheme.
+///
+/// That is for rows we have grad for, we update var, accum and linear as follows:
+/// grad_with_shrinkage = grad + 2 * l2_shrinkage * var
+/// accum_new = accum + grad_with_shrinkage * grad_with_shrinkage
+/// linear += grad_with_shrinkage +
+///     (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var
+/// quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2
+/// var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0
+/// accum = accum_new
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - linear: Should be from a Variable().
+///     - grad: The gradient.
+///     - indices: A vector of indices into the first dimension of var and accum.
+///     - lr: Scaling factor. Must be a scalar.
+///     - l1: L1 regularization. Must be a scalar.
+///     - l2: L2 shrinkage regulariation. Must be a scalar.
+///     - lr_power: Scaling factor. Must be a scalar.
+///
+/// - Attr use_locking: If `True`, updating of the var and accum tensors will be protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyFtrlV2<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    linear: ResourceHandle,
+    grad: Tensor<T>,
+    indices: Tensor<Tindices>,
+    lr: Tensor<T>,
+    l1: Tensor<T>,
+    l2: Tensor<T>,
+    l2Shrinkage: Tensor<T>,
+    lrPower: Tensor<T>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceSparseApplyFtrlV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(linear)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.addInput(lr)
+    op.addInput(l1)
+    op.addInput(l2)
+    op.addInput(l2Shrinkage)
+    op.addInput(lrPower)
+    op.execute()
+}
+
+/// Update relevant entries in '*var' and '*accum' according to the momentum scheme.
+///
+/// Set use_nesterov = True if you want to use Nesterov momentum.
+///
+/// That is for rows we have grad for, we update var and accum as follows:
+///
+/// accum = accum * momentum - lr * grad
+/// var += accum
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - lr: Learning rate. Must be a scalar.
+///     - grad: The gradient.
+///     - indices: A vector of indices into the first dimension of var and accum.
+///     - momentum: Momentum. Must be a scalar.
+///
+/// - Attrs:
+///     - use_locking: If `True`, updating of the var and accum tensors will be protected
+///         by a lock; otherwise the behavior is undefined, but may exhibit less
+///         contention.
+///     - use_nesterov: If `True`, the tensor passed to compute grad will be
+///         var + momentum * accum, so in the end, the var you get is actually
+///         var + momentum * accum.
+@inlinable @inline(__always)
+public static func resourceSparseApplyKerasMomentum<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    lr: Tensor<T>,
+    grad: Tensor<T>,
+    indices: Tensor<Tindices>,
+    momentum: Tensor<T>,
+    useLocking: Bool = false,
+    useNesterov: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceSparseApplyKerasMomentum", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.updateAttribute("use_nesterov", useNesterov)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(lr)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.addInput(momentum)
+    op.execute()
+}
+
+/// Update relevant entries in '*var' and '*accum' according to the momentum scheme.
+///
+/// Set use_nesterov = True if you want to use Nesterov momentum.
+///
+/// That is for rows we have grad for, we update var and accum as follows:
+///
+/// accum = accum * momentum + grad
+/// var -= lr * accum
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - lr: Learning rate. Must be a scalar.
+///     - grad: The gradient.
+///     - indices: A vector of indices into the first dimension of var and accum.
+///     - momentum: Momentum. Must be a scalar.
+///
+/// - Attrs:
+///     - use_locking: If `True`, updating of the var and accum tensors will be protected
+///         by a lock; otherwise the behavior is undefined, but may exhibit less
+///         contention.
+///     - use_nesterov: If `True`, the tensor passed to compute grad will be
+///         var - lr * momentum * accum, so in the end, the var you get is actually
+///         var - lr * momentum * accum.
+@inlinable @inline(__always)
+public static func resourceSparseApplyMomentum<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    lr: Tensor<T>,
+    grad: Tensor<T>,
+    indices: Tensor<Tindices>,
+    momentum: Tensor<T>,
+    useLocking: Bool = false,
+    useNesterov: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceSparseApplyMomentum", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.updateAttribute("use_nesterov", useNesterov)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(lr)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.addInput(momentum)
+    op.execute()
+}
+
+/// Sparse update entries in '*var' and '*accum' according to FOBOS algorithm.
+///
+/// That is for rows we have grad for, we update var and accum as follows:
+/// accum += grad * grad
+/// prox_v = var
+/// prox_v -= lr * grad * (1 / sqrt(accum))
+/// var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - accum: Should be from a Variable().
+///     - lr: Learning rate. Must be a scalar.
+///     - l1: L1 regularization. Must be a scalar.
+///     - l2: L2 regularization. Must be a scalar.
+///     - grad: The gradient.
+///     - indices: A vector of indices into the first dimension of var and accum.
+///
+/// - Attr use_locking: If True, updating of the var and accum tensors will be protected by
+///     a lock; otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyProximalAdagrad<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    var_: ResourceHandle,
+    accum: ResourceHandle,
+    lr: Tensor<T>,
+    l1: Tensor<T>,
+    l2: Tensor<T>,
+    grad: Tensor<T>,
+    indices: Tensor<Tindices>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceSparseApplyProximalAdagrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(accum)
+    op.addInput(lr)
+    op.addInput(l1)
+    op.addInput(l2)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.execute()
+}
+
+/// Sparse update '*var' as FOBOS algorithm with fixed learning rate.
+///
+/// That is for rows we have grad for, we update var as follows:
+/// prox_v = var - alpha * grad
+/// var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - alpha: Scaling factor. Must be a scalar.
+///     - l1: L1 regularization. Must be a scalar.
+///     - l2: L2 regularization. Must be a scalar.
+///     - grad: The gradient.
+///     - indices: A vector of indices into the first dimension of var and accum.
+///
+/// - Attr use_locking: If True, the subtraction will be protected by a lock;
+///     otherwise the behavior is undefined, but may exhibit less contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyProximalGradientDescent<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    var_: ResourceHandle,
+    alpha: Tensor<T>,
+    l1: Tensor<T>,
+    l2: Tensor<T>,
+    grad: Tensor<T>,
+    indices: Tensor<Tindices>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceSparseApplyProximalGradientDescent", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(alpha)
+    op.addInput(l1)
+    op.addInput(l2)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.execute()
+}
+
+/// Update '*var' according to the RMSProp algorithm.
+///
+/// Note that in dense implementation of this algorithm, ms and mom will
+/// update even if the grad is zero, but in this sparse implementation, ms
+/// and mom will not update in iterations during which the grad is zero.
+///
+/// mean_square = decay * mean_square + (1-decay) * gradient ** 2
+/// Delta = learning_rate * gradient / sqrt(mean_square + epsilon)
+///
+/// ms <- rho * ms_{t-1} + (1-rho) * grad * grad
+/// mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms + epsilon)
+/// var <- var - mom
+///
+/// - Parameters:
+///     - var: Should be from a Variable().
+///     - ms: Should be from a Variable().
+///     - mom: Should be from a Variable().
+///     - lr: Scaling factor. Must be a scalar.
+///     - rho: Decay rate. Must be a scalar.
+///     - epsilon: Ridge term. Must be a scalar.
+///     - grad: The gradient.
+///     - indices: A vector of indices into the first dimension of var, ms and mom.
+///
+/// - Attr use_locking: If `True`, updating of the var, ms, and mom tensors is protected
+///     by a lock; otherwise the behavior is undefined, but may exhibit less
+///     contention.
+@inlinable @inline(__always)
+public static func resourceSparseApplyRMSProp<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    var_: ResourceHandle,
+    ms: ResourceHandle,
+    mom: ResourceHandle,
+    lr: Tensor<T>,
+    rho: Tensor<T>,
+    momentum: Tensor<T>,
+    epsilon: Tensor<T>,
+    grad: Tensor<T>,
+    indices: Tensor<Tindices>,
+    useLocking: Bool = false
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceSparseApplyRMSProp", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("use_locking", useLocking)
+    op.addInput(var_)
+    op.addInput(ms)
+    op.addInput(mom)
+    op.addInput(lr)
+    op.addInput(rho)
+    op.addInput(momentum)
+    op.addInput(epsilon)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.execute()
+}
+
+/// Assign `value` to the sliced l-value reference of `ref`.
+///
+/// The values of `value` are assigned to the positions in the variable
+/// `ref` that are selected by the slice parameters. The slice parameters
+/// `begin, `end`, `strides`, etc. work exactly as in `StridedSlice`.
+///
+/// NOTE this op currently does not support broadcasting and so `value`'s
+/// shape must be exactly the shape produced by the slice of `ref`.
+@inlinable @inline(__always)
+public static func resourceStridedSliceAssign<
+    T: TensorFlowScalar,
+    Index: BinaryInteger & TensorFlowScalar
+>(
+    ref: ResourceHandle,
+    begin: Tensor<Index>,
+    end: Tensor<Index>,
+    strides: Tensor<Index>,
+    value: Tensor<T>,
+    beginMask: Int64 = 0,
+    endMask: Int64 = 0,
+    ellipsisMask: Int64 = 0,
+    newAxisMask: Int64 = 0,
+    shrinkAxisMask: Int64 = 0
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceStridedSliceAssign", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Index", Index.tensorFlowDataType)
+    op.updateAttribute("begin_mask", beginMask)
+    op.updateAttribute("end_mask", endMask)
+    op.updateAttribute("ellipsis_mask", ellipsisMask)
+    op.updateAttribute("new_axis_mask", newAxisMask)
+    op.updateAttribute("shrink_axis_mask", shrinkAxisMask)
+    op.addInput(ref)
+    op.addInput(begin)
+    op.addInput(end)
+    op.addInput(strides)
+    op.addInput(value)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func resourceUsingOp(
+    resource: ResourceHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("ResourceUsingOp", nOutputs)
+    op.addInput(resource)
+    op.execute()
+}
+
+/// Restores a tensor from checkpoint files.
+///
+/// Reads a tensor stored in one or several files. If there are several files (for
+/// instance because a tensor was saved as slices), `file_pattern` may contain
+/// wildcard symbols (`*` and `?`) in the filename portion only, not in the
+/// directory portion.
+///
+/// If a `file_pattern` matches several files, `preferred_shard` can be used to hint
+/// in which file the requested tensor is likely to be found. This op will first
+/// open the file at index `preferred_shard` in the list of matching files and try
+/// to restore tensors from that file.  Only if some tensors or tensor slices are
+/// not found in that first file, then the Op opens all the files. Setting
+/// `preferred_shard` to match the value passed as the `shard` input
+/// of a matching `Save` Op may speed up Restore.  This attribute only affects
+/// performance, not correctness.  The default value -1 means files are processed in
+/// order.
+///
+/// See also `RestoreSlice`.
+///
+/// - Parameters:
+///     - file_pattern: Must have a single element. The pattern of the files from
+///         which we read the tensor.
+///     - tensor_name: Must have a single element. The name of the tensor to be
+///         restored.
+///
+/// - Attrs:
+///     - dt: The type of the tensor to be restored.
+///     - preferred_shard: Index of file to open first if multiple files match
+///         `file_pattern`.
+///
+/// - Output tensor: The restored tensor.
+@inlinable @inline(__always)
+public static func restore<Dt: TensorFlowScalar>(
+    filePattern: StringTensor,
+    tensorName: StringTensor,
+    preferredShard: Int64 = -1
+) -> Tensor<Dt> {
+  let nOutputs = Int(1)
+    let op = makeOp("Restore", nOutputs)
+    op.updateAttribute("dt", Dt.tensorFlowDataType)
+    op.updateAttribute("preferred_shard", preferredShard)
+    op.addInput(filePattern)
+    op.addInput(tensorName)
+    return op.execute(Int(1))
+}
+
+/// Restores a tensor from checkpoint files.
+///
+/// This is like `Restore` except that restored tensor can be listed as filling
+/// only a slice of a larger tensor.  `shape_and_slice` specifies the shape of the
+/// larger tensor and the slice that the restored tensor covers.
+///
+/// The `shape_and_slice` input has the same format as the
+/// elements of the `shapes_and_slices` input of the `SaveSlices` op.
+///
+/// - Parameters:
+///     - file_pattern: Must have a single element. The pattern of the files from
+///         which we read the tensor.
+///     - tensor_name: Must have a single element. The name of the tensor to be
+///         restored.
+///     - shape_and_slice: Scalar. The shapes and slice specifications to use when
+///         restoring a tensors.
+///
+/// - Attrs:
+///     - dt: The type of the tensor to be restored.
+///     - preferred_shard: Index of file to open first if multiple files match
+///         `file_pattern`. See the documentation for `Restore`.
+///
+/// - Output tensor: The restored tensor.
+@inlinable @inline(__always)
+public static func restoreSlice<Dt: TensorFlowScalar>(
+    filePattern: StringTensor,
+    tensorName: StringTensor,
+    shapeAndSlice: StringTensor,
+    preferredShard: Int64 = -1
+) -> Tensor<Dt> {
+  let nOutputs = Int(1)
+    let op = makeOp("RestoreSlice", nOutputs)
+    op.updateAttribute("dt", Dt.tensorFlowDataType)
+    op.updateAttribute("preferred_shard", preferredShard)
+    op.addInput(filePattern)
+    op.addInput(tensorName)
+    op.addInput(shapeAndSlice)
+    return op.execute(Int(1))
+}
+
+/// Restores tensors from a V2 checkpoint.
+///
+/// For backward compatibility with the V1 format, this Op currently allows
+/// restoring from a V1 checkpoint as well:
+///   - This Op first attempts to find the V2 index file pointed to by "prefix", and
+///     if found proceed to read it as a V2 checkpoint;
+///   - Otherwise the V1 read path is invoked.
+/// Relying on this behavior is not recommended, as the ability to fall back to read
+/// V1 might be deprecated and eventually removed.
+///
+/// By default, restores the named tensors in full.  If the caller wishes to restore
+/// specific slices of stored tensors, "shape_and_slices" should be non-empty
+/// strings and correspondingly well-formed.
+///
+/// Callers must ensure all the named tensors are indeed stored in the checkpoint.
+///
+/// - Parameters:
+///     - prefix: Must have a single element.  The prefix of a V2 checkpoint.
+///     - tensor_names: shape {N}.  The names of the tensors to be restored.
+///     - shape_and_slices: shape {N}.  The slice specs of the tensors to be restored.
+///         Empty strings indicate that they are non-partitioned tensors.
+///
+/// - Attr dtypes: shape {N}.  The list of expected dtype for the tensors.  Must match
+///     those stored in the checkpoint.
+///
+/// - Output tensors: shape {N}.  The restored tensors, whose shapes are read from the
+///     checkpoint directly.
+@inlinable @inline(__always)
+public static func restoreV2<Dtypes: TensorGroup>(
+    prefix: StringTensor,
+    tensorNames: StringTensor,
+    shapeAndSlices: StringTensor
+) -> Dtypes {
+  let nOutputs = Int(Dtypes._typeList.count)
+    let op = makeOp("RestoreV2", nOutputs)
+    op.updateAttribute("dtypes", Dtypes._typeList)
+    op.addInput(prefix)
+    op.addInput(tensorNames)
+    op.addInput(shapeAndSlices)
+    return op.execute(Int(Dtypes._typeList.count))
+}
+
+@inlinable @inline(__always)
+public static func restrict<T: TensorFlowScalar>(
+    _ a: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Restrict", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func restrict(
+    _ a: StringTensor
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("Restrict", nOutputs)
+    op.updateAttribute("T", TensorDataType(TF_STRING))
+    op.addInput(a)
+    return op.execute(Int(1))
+}
+
+/// Retrieve ADAM embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the ADAM optimization algorithm.
+///     - momenta: Parameter momenta updated by the ADAM optimization algorithm.
+///     - velocities: Parameter velocities updated by the ADAM optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingADAMParameters(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, momenta: Tensor<Float>, velocities: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingADAMParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve ADAM embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the ADAM optimization algorithm.
+///     - momenta: Parameter momenta updated by the ADAM optimization algorithm.
+///     - velocities: Parameter velocities updated by the ADAM optimization algorithm.
+///     - gradient_accumulators: Parameter gradient_accumulators updated by the ADAM optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingADAMParametersGradAccumDebug(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, momenta: Tensor<Float>, velocities: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingADAMParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Retrieve Adadelta embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the Adadelta optimization algorithm.
+///     - accumulators: Parameter accumulators updated by the Adadelta optimization algorithm.
+///     - updates: Parameter updates updated by the Adadelta optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingAdadeltaParameters(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, updates: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingAdadeltaParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve Adadelta embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the Adadelta optimization algorithm.
+///     - accumulators: Parameter accumulators updated by the Adadelta optimization algorithm.
+///     - updates: Parameter updates updated by the Adadelta optimization algorithm.
+///     - gradient_accumulators: Parameter gradient_accumulators updated by the Adadelta optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingAdadeltaParametersGradAccumDebug(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, updates: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingAdadeltaParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Retrieve Adagrad embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the Adagrad optimization algorithm.
+///     - accumulators: Parameter accumulators updated by the Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingAdagradParameters(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingAdagradParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Retrieve Adagrad embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the Adagrad optimization algorithm.
+///     - accumulators: Parameter accumulators updated by the Adagrad optimization algorithm.
+///     - gradient_accumulators: Parameter gradient_accumulators updated by the Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingAdagradParametersGradAccumDebug(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingAdagradParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve centered RMSProp embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the centered RMSProp optimization algorithm.
+///     - ms: Parameter ms updated by the centered RMSProp optimization algorithm.
+///     - mom: Parameter mom updated by the centered RMSProp optimization algorithm.
+///     - mg: Parameter mg updated by the centered RMSProp optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingCenteredRMSPropParameters(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, ms: Tensor<Float>, mom: Tensor<Float>, mg: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingCenteredRMSPropParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Retrieve FTRL embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the FTRL optimization algorithm.
+///     - accumulators: Parameter accumulators updated by the FTRL optimization algorithm.
+///     - linears: Parameter linears updated by the FTRL optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingFTRLParameters(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, linears: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingFTRLParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve FTRL embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the FTRL optimization algorithm.
+///     - accumulators: Parameter accumulators updated by the FTRL optimization algorithm.
+///     - linears: Parameter linears updated by the FTRL optimization algorithm.
+///     - gradient_accumulators: Parameter gradient_accumulators updated by the FTRL optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingFTRLParametersGradAccumDebug(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, linears: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingFTRLParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Retrieve MDL Adagrad Light embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the MDL Adagrad Light optimization algorithm.
+///     - accumulators: Parameter accumulators updated by the MDL Adagrad Light optimization algorithm.
+///     - weights: Parameter weights updated by the MDL Adagrad Light optimization algorithm.
+///     - benefits: Parameter benefits updated by the MDL Adagrad Light optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingMDLAdagradLightParameters(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, weights: Tensor<Float>, benefits: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingMDLAdagradLightParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Retrieve Momentum embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the Momentum optimization algorithm.
+///     - momenta: Parameter momenta updated by the Momentum optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingMomentumParameters(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, momenta: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingMomentumParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Retrieve Momentum embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the Momentum optimization algorithm.
+///     - momenta: Parameter momenta updated by the Momentum optimization algorithm.
+///     - gradient_accumulators: Parameter gradient_accumulators updated by the Momentum optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingMomentumParametersGradAccumDebug(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, momenta: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingMomentumParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve proximal Adagrad embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the proximal Adagrad optimization algorithm.
+///     - accumulators: Parameter accumulators updated by the proximal Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingProximalAdagradParameters(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingProximalAdagradParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Retrieve proximal Adagrad embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the proximal Adagrad optimization algorithm.
+///     - accumulators: Parameter accumulators updated by the proximal Adagrad optimization algorithm.
+///     - gradient_accumulators: Parameter gradient_accumulators updated by the proximal Adagrad optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, accumulators: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingProximalAdagradParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve RMSProp embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the RMSProp optimization algorithm.
+///     - ms: Parameter ms updated by the RMSProp optimization algorithm.
+///     - mom: Parameter mom updated by the RMSProp optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingRMSPropParameters(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, ms: Tensor<Float>, mom: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingRMSPropParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Retrieve RMSProp embedding parameters with debug support.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Outputs:
+///     - parameters: Parameter parameters updated by the RMSProp optimization algorithm.
+///     - ms: Parameter ms updated by the RMSProp optimization algorithm.
+///     - mom: Parameter mom updated by the RMSProp optimization algorithm.
+///     - gradient_accumulators: Parameter gradient_accumulators updated by the RMSProp optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingRMSPropParametersGradAccumDebug(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> (parameters: Tensor<Float>, ms: Tensor<Float>, mom: Tensor<Float>, gradientAccumulators: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingRMSPropParametersGradAccumDebug", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Retrieve SGD embedding parameters.
+///
+/// An op that retrieves optimization parameters from embedding to host
+/// memory. Must be preceded by a ConfigureTPUEmbeddingHost op that sets up
+/// the correct embedding table configuration. For example, this op is
+/// used to retrieve updated parameters before saving a checkpoint.
+///
+/// - Output parameters: Parameter parameters updated by the stochastic gradient descent optimization algorithm.
+@inlinable @inline(__always)
+public static func retrieveTPUEmbeddingStochasticGradientDescentParameters(
+    tableId: Int64 = -1,
+    tableName: String,
+    numShards: Int64,
+    shardId: Int64
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("RetrieveTPUEmbeddingStochasticGradientDescentParameters", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("table_name", tableName)
+    op.updateAttribute("num_shards", numShards)
+    op.updateAttribute("shard_id", shardId)
+    return op.execute(Int(1))
+}
+
+/// Reverses specific dimensions of a tensor.
+///
+/// Given a `tensor`, and a `bool` tensor `dims` representing the dimensions
+/// of `tensor`, this operation reverses each dimension i of `tensor` where
+/// `dims[i]` is `True`.
+///
+/// `tensor` can have up to 8 dimensions. The number of dimensions
+/// of `tensor` must equal the number of elements in `dims`. In other words:
+///
+/// `rank(tensor) = size(dims)`
+///
+/// For example:
+///
+/// ```
+/// # tensor 't' is [[[[ 0,  1,  2,  3],
+/// #                  [ 4,  5,  6,  7],
+/// #                  [ 8,  9, 10, 11]],
+/// #                 [[12, 13, 14, 15],
+/// #                  [16, 17, 18, 19],
+/// #                  [20, 21, 22, 23]]]]
+/// # tensor 't' shape is [1, 2, 3, 4]
+///
+/// # 'dims' is [False, False, False, True]
+/// reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
+///                         [ 7,  6,  5,  4],
+///                         [ 11, 10, 9, 8]],
+///                        [[15, 14, 13, 12],
+///                         [19, 18, 17, 16],
+///                         [23, 22, 21, 20]]]]
+///
+/// # 'dims' is [False, True, False, False]
+/// reverse(t, dims) ==> [[[[12, 13, 14, 15],
+///                         [16, 17, 18, 19],
+///                         [20, 21, 22, 23]
+///                        [[ 0,  1,  2,  3],
+///                         [ 4,  5,  6,  7],
+///                         [ 8,  9, 10, 11]]]]
+///
+/// # 'dims' is [False, False, True, False]
+/// reverse(t, dims) ==> [[[[8, 9, 10, 11],
+///                         [4, 5, 6, 7],
+///                         [0, 1, 2, 3]]
+///                        [[20, 21, 22, 23],
+///                         [16, 17, 18, 19],
+///                         [12, 13, 14, 15]]]]
+/// ```
+///
+/// - Parameters:
+///     - tensor: Up to 8-D.
+///     - dims: 1-D. The dimensions to reverse.
+///
+/// - Output output: The same shape as `tensor`.
+@inlinable @inline(__always)
+public static func reverse<T: TensorFlowScalar>(
+    _ tensor: Tensor<T>,
+    dims: Tensor<Bool>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Reverse", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(tensor)
+    op.addInput(dims)
+    return op.execute(Int(1))
+}
+
+/// Reverses specific dimensions of a tensor.
+///
+/// Given a `tensor`, and a `bool` tensor `dims` representing the dimensions
+/// of `tensor`, this operation reverses each dimension i of `tensor` where
+/// `dims[i]` is `True`.
+///
+/// `tensor` can have up to 8 dimensions. The number of dimensions
+/// of `tensor` must equal the number of elements in `dims`. In other words:
+///
+/// `rank(tensor) = size(dims)`
+///
+/// For example:
+///
+/// ```
+/// # tensor 't' is [[[[ 0,  1,  2,  3],
+/// #                  [ 4,  5,  6,  7],
+/// #                  [ 8,  9, 10, 11]],
+/// #                 [[12, 13, 14, 15],
+/// #                  [16, 17, 18, 19],
+/// #                  [20, 21, 22, 23]]]]
+/// # tensor 't' shape is [1, 2, 3, 4]
+///
+/// # 'dims' is [False, False, False, True]
+/// reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
+///                         [ 7,  6,  5,  4],
+///                         [ 11, 10, 9, 8]],
+///                        [[15, 14, 13, 12],
+///                         [19, 18, 17, 16],
+///                         [23, 22, 21, 20]]]]
+///
+/// # 'dims' is [False, True, False, False]
+/// reverse(t, dims) ==> [[[[12, 13, 14, 15],
+///                         [16, 17, 18, 19],
+///                         [20, 21, 22, 23]
+///                        [[ 0,  1,  2,  3],
+///                         [ 4,  5,  6,  7],
+///                         [ 8,  9, 10, 11]]]]
+///
+/// # 'dims' is [False, False, True, False]
+/// reverse(t, dims) ==> [[[[8, 9, 10, 11],
+///                         [4, 5, 6, 7],
+///                         [0, 1, 2, 3]]
+///                        [[20, 21, 22, 23],
+///                         [16, 17, 18, 19],
+///                         [12, 13, 14, 15]]]]
+/// ```
+///
+/// - Parameters:
+///     - tensor: Up to 8-D.
+///     - dims: 1-D. The dimensions to reverse.
+///
+/// - Output output: The same shape as `tensor`.
+@inlinable @inline(__always)
+public static func reverse(
+    _ tensor: StringTensor,
+    dims: Tensor<Bool>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("Reverse", nOutputs)
+    op.updateAttribute("T", TensorDataType(TF_STRING))
+    op.addInput(tensor)
+    op.addInput(dims)
+    return op.execute(Int(1))
+}
+
+/// Reverses variable length slices.
+///
+/// This op first slices `input` along the dimension `batch_dim`, and for each
+/// slice `i`, reverses the first `seq_lengths[i]` elements along
+/// the dimension `seq_dim`.
+///
+/// The elements of `seq_lengths` must obey `seq_lengths[i] <= input.dims[seq_dim]`,
+/// and `seq_lengths` must be a vector of length `input.dims[batch_dim]`.
+///
+/// The output slice `i` along dimension `batch_dim` is then given by input
+/// slice `i`, with the first `seq_lengths[i]` slices along dimension
+/// `seq_dim` reversed.
+///
+/// For example:
+///
+/// ```
+/// # Given this:
+/// batch_dim = 0
+/// seq_dim = 1
+/// input.dims = (4, 8, ...)
+/// seq_lengths = [7, 2, 3, 5]
+///
+/// # then slices of input are reversed on seq_dim, but only up to seq_lengths:
+/// output[0, 0:7, :, ...] = input[0, 7:0:-1, :, ...]
+/// output[1, 0:2, :, ...] = input[1, 2:0:-1, :, ...]
+/// output[2, 0:3, :, ...] = input[2, 3:0:-1, :, ...]
+/// output[3, 0:5, :, ...] = input[3, 5:0:-1, :, ...]
+///
+/// # while entries past seq_lens are copied through:
+/// output[0, 7:, :, ...] = input[0, 7:, :, ...]
+/// output[1, 2:, :, ...] = input[1, 2:, :, ...]
+/// output[2, 3:, :, ...] = input[2, 3:, :, ...]
+/// output[3, 2:, :, ...] = input[3, 2:, :, ...]
+/// ```
+///
+/// In contrast, if:
+///
+/// ```
+/// # Given this:
+/// batch_dim = 2
+/// seq_dim = 0
+/// input.dims = (8, ?, 4, ...)
+/// seq_lengths = [7, 2, 3, 5]
+///
+/// # then slices of input are reversed on seq_dim, but only up to seq_lengths:
+/// output[0:7, :, 0, :, ...] = input[7:0:-1, :, 0, :, ...]
+/// output[0:2, :, 1, :, ...] = input[2:0:-1, :, 1, :, ...]
+/// output[0:3, :, 2, :, ...] = input[3:0:-1, :, 2, :, ...]
+/// output[0:5, :, 3, :, ...] = input[5:0:-1, :, 3, :, ...]
+///
+/// # while entries past seq_lens are copied through:
+/// output[7:, :, 0, :, ...] = input[7:, :, 0, :, ...]
+/// output[2:, :, 1, :, ...] = input[2:, :, 1, :, ...]
+/// output[3:, :, 2, :, ...] = input[3:, :, 2, :, ...]
+/// output[2:, :, 3, :, ...] = input[2:, :, 3, :, ...]
+/// ```
+///
+/// - Parameters:
+///     - input: The input to reverse.
+///     - seq_lengths: 1-D with length `input.dims(batch_dim)` and
+///         `max(seq_lengths) <= input.dims(seq_dim)`
+///
+/// - Attrs:
+///     - seq_dim: The dimension which is partially reversed.
+///     - batch_dim: The dimension along which reversal is performed.
+///
+/// - Output output: The partially reversed input. It has the same shape as `input`.
+@inlinable @inline(__always)
+public static func reverseSequence<
+    T: TensorFlowScalar,
+    Tlen: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    seqLengths: Tensor<Tlen>,
+    seqDim: Int64,
+    batchDim: Int64 = 0
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ReverseSequence", nOutputs)
+    op.updateAttribute("seq_dim", seqDim)
+    op.updateAttribute("batch_dim", batchDim)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tlen", Tlen.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(seqLengths)
+    return op.execute(Int(1))
+}
+
+/// Reverses specific dimensions of a tensor.
+///
+/// NOTE `tf.reverse` has now changed behavior in preparation for 1.0.
+/// `tf.reverse_v2` is currently an alias that will be deprecated before TF 1.0.
+///
+/// Given a `tensor`, and a `int32` tensor `axis` representing the set of
+/// dimensions of `tensor` to reverse. This operation reverses each dimension
+/// `i` for which there exists `j` s.t. `axis[j] == i`.
+///
+/// `tensor` can have up to 8 dimensions. The number of dimensions specified
+/// in `axis` may be 0 or more entries. If an index is specified more than
+/// once, a InvalidArgument error is raised.
+///
+/// For example:
+///
+/// ```
+/// # tensor 't' is [[[[ 0,  1,  2,  3],
+/// #                  [ 4,  5,  6,  7],
+/// #                  [ 8,  9, 10, 11]],
+/// #                 [[12, 13, 14, 15],
+/// #                  [16, 17, 18, 19],
+/// #                  [20, 21, 22, 23]]]]
+/// # tensor 't' shape is [1, 2, 3, 4]
+///
+/// # 'dims' is [3] or 'dims' is [-1]
+/// reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
+///                         [ 7,  6,  5,  4],
+///                         [ 11, 10, 9, 8]],
+///                        [[15, 14, 13, 12],
+///                         [19, 18, 17, 16],
+///                         [23, 22, 21, 20]]]]
+///
+/// # 'dims' is '[1]' (or 'dims' is '[-3]')
+/// reverse(t, dims) ==> [[[[12, 13, 14, 15],
+///                         [16, 17, 18, 19],
+///                         [20, 21, 22, 23]
+///                        [[ 0,  1,  2,  3],
+///                         [ 4,  5,  6,  7],
+///                         [ 8,  9, 10, 11]]]]
+///
+/// # 'dims' is '[2]' (or 'dims' is '[-2]')
+/// reverse(t, dims) ==> [[[[8, 9, 10, 11],
+///                         [4, 5, 6, 7],
+///                         [0, 1, 2, 3]]
+///                        [[20, 21, 22, 23],
+///                         [16, 17, 18, 19],
+///                         [12, 13, 14, 15]]]]
+/// ```
+///
+/// - Parameters:
+///     - tensor: Up to 8-D.
+///     - axis: 1-D. The indices of the dimensions to reverse. Must be in the range
+///         `[-rank(tensor), rank(tensor))`.
+///
+/// - Output output: The same shape as `tensor`.
+@inlinable @inline(__always)
+public static func reverseV2<
+    Tidx: BinaryInteger & TensorFlowScalar,
+    T: TensorFlowScalar
+>(
+    _ tensor: Tensor<T>,
+    axis: Tensor<Tidx>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ReverseV2", nOutputs)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(tensor)
+    op.addInput(axis)
+    return op.execute(Int(1))
+}
+
+/// Reverses specific dimensions of a tensor.
+///
+/// NOTE `tf.reverse` has now changed behavior in preparation for 1.0.
+/// `tf.reverse_v2` is currently an alias that will be deprecated before TF 1.0.
+///
+/// Given a `tensor`, and a `int32` tensor `axis` representing the set of
+/// dimensions of `tensor` to reverse. This operation reverses each dimension
+/// `i` for which there exists `j` s.t. `axis[j] == i`.
+///
+/// `tensor` can have up to 8 dimensions. The number of dimensions specified
+/// in `axis` may be 0 or more entries. If an index is specified more than
+/// once, a InvalidArgument error is raised.
+///
+/// For example:
+///
+/// ```
+/// # tensor 't' is [[[[ 0,  1,  2,  3],
+/// #                  [ 4,  5,  6,  7],
+/// #                  [ 8,  9, 10, 11]],
+/// #                 [[12, 13, 14, 15],
+/// #                  [16, 17, 18, 19],
+/// #                  [20, 21, 22, 23]]]]
+/// # tensor 't' shape is [1, 2, 3, 4]
+///
+/// # 'dims' is [3] or 'dims' is [-1]
+/// reverse(t, dims) ==> [[[[ 3,  2,  1,  0],
+///                         [ 7,  6,  5,  4],
+///                         [ 11, 10, 9, 8]],
+///                        [[15, 14, 13, 12],
+///                         [19, 18, 17, 16],
+///                         [23, 22, 21, 20]]]]
+///
+/// # 'dims' is '[1]' (or 'dims' is '[-3]')
+/// reverse(t, dims) ==> [[[[12, 13, 14, 15],
+///                         [16, 17, 18, 19],
+///                         [20, 21, 22, 23]
+///                        [[ 0,  1,  2,  3],
+///                         [ 4,  5,  6,  7],
+///                         [ 8,  9, 10, 11]]]]
+///
+/// # 'dims' is '[2]' (or 'dims' is '[-2]')
+/// reverse(t, dims) ==> [[[[8, 9, 10, 11],
+///                         [4, 5, 6, 7],
+///                         [0, 1, 2, 3]]
+///                        [[20, 21, 22, 23],
+///                         [16, 17, 18, 19],
+///                         [12, 13, 14, 15]]]]
+/// ```
+///
+/// - Parameters:
+///     - tensor: Up to 8-D.
+///     - axis: 1-D. The indices of the dimensions to reverse. Must be in the range
+///         `[-rank(tensor), rank(tensor))`.
+///
+/// - Output output: The same shape as `tensor`.
+@inlinable @inline(__always)
+public static func reverseV2<Tidx: BinaryInteger & TensorFlowScalar>(
+    _ tensor: StringTensor,
+    axis: Tensor<Tidx>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("ReverseV2", nOutputs)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.updateAttribute("T", TensorDataType(TF_STRING))
+    op.addInput(tensor)
+    op.addInput(axis)
+    return op.execute(Int(1))
+}
+
+/// Elementwise computes the bitwise right-shift of `x` and `y`.
+///
+/// Performs a logical shift for unsigned integer types, and an arithmetic shift
+/// for signed integer types.
+///
+/// If `y` is negative, or greater than or equal to than the width of `x` in bits
+/// the result is implementation defined.
+@inlinable @inline(__always)
+public static func rightShift<T: BinaryInteger & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("RightShift", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns element-wise integer closest to x.
+///
+/// If the result is midway between two representable values,
+/// the even representable is chosen.
+/// For example:
+///
+/// ```
+/// rint(-1.5) ==> -2.0
+/// rint(0.5000001) ==> 1.0
+/// rint([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) ==> [-2., -2., -0., 0., 2., 2., 2.]
+/// ```
+@inlinable @inline(__always)
+public static func rint<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Rint", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Rolls the elements of a tensor along an axis.
+///
+/// The elements are shifted positively (towards larger indices) by the offset of
+/// `shift` along the dimension of `axis`. Negative `shift` values will shift
+/// elements in the opposite direction. Elements that roll passed the last position
+/// will wrap around to the first and vice versa. Multiple shifts along multiple
+/// axes may be specified.
+///
+/// For example:
+///
+/// ```
+/// # 't' is [0, 1, 2, 3, 4]
+/// roll(t, shift=2, axis=0) ==> [3, 4, 0, 1, 2]
+///
+/// # shifting along multiple dimensions
+/// # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
+/// roll(t, shift=[1, -2], axis=[0, 1]) ==> [[7, 8, 9, 5, 6], [2, 3, 4, 0, 1]]
+///
+/// # shifting along the same axis multiple times
+/// # 't' is [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
+/// roll(t, shift=[2, -3], axis=[1, 1]) ==> [[1, 2, 3, 4, 0], [6, 7, 8, 9, 5]]
+/// ```
+///
+/// - Parameters:
+///     - shift: Dimension must be 0-D or 1-D. `shift[i]` specifies the number of places by which
+///         elements are shifted positively (towards larger indices) along the dimension
+///         specified by `axis[i]`. Negative shifts will roll the elements in the opposite
+///         direction.
+///     - axis: Dimension must be 0-D or 1-D. `axis[i]` specifies the dimension that the shift
+///         `shift[i]` should occur. If the same axis is referenced more than once, the
+///         total shift for that axis will be the sum of all the shifts that belong to that
+///         axis.
+///
+/// - Output output: Has the same shape and size as the input. The elements are shifted
+///     positively (towards larger indices) by the offsets of `shift` along the
+///     dimensions of `axis`.
+@inlinable @inline(__always)
+public static func roll<
+    T: TensorFlowScalar,
+    Tshift: BinaryInteger & TensorFlowScalar,
+    Taxis: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    shift: Tensor<Tshift>,
+    axis: Tensor<Taxis>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Roll", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tshift", Tshift.tensorFlowDataType)
+    op.updateAttribute("Taxis", Taxis.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(shift)
+    op.addInput(axis)
+    return op.execute(Int(1))
+}
+
+/// Rounds the values of a tensor to the nearest integer, element-wise.
+///
+/// Rounds half to even.  Also known as bankers rounding. If you want to round
+/// according to the current system rounding mode use std::cint.
+@inlinable @inline(__always)
+public static func round<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Round", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Perform batches of RPC requests.
+///
+/// This op asynchronously performs either a single RPC request, or a batch
+/// of requests.  RPC requests are defined by three main parameters:
+///
+///   - `address` (the host+port or BNS address of the request)
+///   - `method` (the RPC method name for the request)
+///   - `request` (the serialized proto string, or vector of strings,
+///      of the RPC request argument).
+///
+/// For example, if you have an RPC service running on port localhost:2345,
+/// and its interface is configured with the following proto declaration:
+///
+/// ```
+/// service MyService {
+///   rpc MyMethod(MyRequestProto) returns (MyResponseProto) {
+///   }
+/// };
+/// ```
+///
+/// then call this op with arguments:
+///
+/// ```
+/// address = "localhost:2345"
+/// method = "MyService/MyMethod"
+/// ```
+///
+/// The `request` tensor is a string tensor representing serialized `MyRequestProto`
+/// strings; and the output string tensor `response` will have the same shape
+/// and contain (upon successful completion) corresponding serialized
+/// `MyResponseProto` strings.
+///
+/// For example, to send a single, empty, `MyRequestProto`, call
+/// this op with `request = ""`.  To send 5 **parallel** empty requests,
+/// call this op with `request = ["", "", "", "", ""]`.
+///
+/// More generally, one can create a batch of `MyRequestProto` serialized protos
+/// from regular batched tensors using the `encode_proto` op, and convert
+/// the response `MyResponseProto` serialized protos to batched tensors
+/// using the `decode_proto` op.
+///
+/// **NOTE** Working with serialized proto strings is faster than instantiating
+/// actual proto objects in memory, so no performance degradation is expected
+/// compared to writing custom kernels for this workflow.
+///
+/// If the connection fails or the remote worker returns an error
+/// status, the op reraises this exception locally.
+///
+/// See the `TryRpc` op if you prefer to handle RPC failures manually in the graph.
+///
+/// - Parameters:
+///     - address: `0-D` or `1-D`.  The address (i.e. host_name:port) of the RPC server.
+///         If this tensor has more than 1 element, then multiple parallel rpc requests
+///         are sent.  This argument broadcasts with `method` and `request`.
+///     - method: `0-D` or `1-D`.  The method address on the RPC server.
+///         If this tensor has more than 1 element, then multiple parallel rpc requests
+///         are sent.  This argument broadcasts with `address` and `request`.
+///     - request: `0-D` or `1-D`.  Serialized proto strings: the rpc request argument.
+///         If this tensor has more than 1 element, then multiple parallel rpc requests
+///         are sent.  This argument broadcasts with `address` and `method`.
+///
+/// - Attrs:
+///     - protocol: RPC protocol to use.  Empty string means use the default protocol.
+///         Options include 'grpc'.
+///     - fail_fast: `boolean`. If `true` (default), then failures to connect
+///         (i.e., the server does not immediately respond) cause an RPC failure.
+///     - timeout_in_ms: `int`. If `0` (default), then the kernel will run the RPC
+///         request and only time out if the RPC deadline passes or the session times out.
+///         If this value is greater than `0`, then the op will raise an exception if
+///         the RPC takes longer than `timeout_in_ms`.
+///
+/// - Output response: Same shape as `request`. Serialized proto strings: the rpc responses.
+@inlinable @inline(__always)
+public static func rpc(
+    address: StringTensor,
+    method: StringTensor,
+    request: StringTensor,
+    protocol_: String,
+    failFast: Bool = true,
+    timeoutInMs: Int64 = 0
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("Rpc", nOutputs)
+    op.updateAttribute("protocol", protocol_)
+    op.updateAttribute("fail_fast", failFast)
+    op.updateAttribute("timeout_in_ms", timeoutInMs)
+    op.addInput(address)
+    op.addInput(method)
+    op.addInput(request)
+    return op.execute(Int(1))
+}
+
+/// Computes reciprocal of square root of x element-wise.
+///
+/// I.e., \\(y = 1 / \sqrt{x}\\).
+@inlinable @inline(__always)
+public static func rsqrt<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Rsqrt", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient for the rsqrt of `x` wrt its input.
+///
+/// Specifically, `grad = dy * -0.5 * y^3`, where `y = rsqrt(x)`, and `dy`
+/// is the corresponding input gradient.
+@inlinable @inline(__always)
+public static func rsqrtGrad<T: FloatingPoint & TensorFlowScalar>(
+    _ y: Tensor<T>,
+    dy: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("RsqrtGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(y)
+    op.addInput(dy)
+    return op.execute(Int(1))
+}
+
+/// Generate a single randomly distorted bounding box for an image.
+///
+/// Bounding box annotations are often supplied in addition to ground-truth labels
+/// in image recognition or object localization tasks. A common technique for
+/// training such a system is to randomly distort an image while preserving
+/// its content, i.e. *data augmentation*. This Op outputs a randomly distorted
+/// localization of an object, i.e. bounding box, given an `image_size`,
+/// `bounding_boxes` and a series of constraints.
+///
+/// The output of this Op is a single bounding box that may be used to crop the
+/// original image. The output is returned as 3 tensors: `begin`, `size` and
+/// `bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the
+/// image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize
+/// what the bounding box looks like.
+///
+/// Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The
+/// bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
+/// height of the underlying image.
+///
+/// For example,
+///
+/// ```python
+///     # Generate a single distorted bounding box.
+///     begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
+///         tf.shape(image),
+///         bounding_boxes=bounding_boxes)
+///
+///     # Draw the bounding box in an image summary.
+///     image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0),
+///                                                   bbox_for_draw)
+///     tf.summary.image('images_with_box', image_with_box)
+///
+///     # Employ the bounding box to distort the image.
+///     distorted_image = tf.slice(image, begin, size)
+/// ```
+///
+/// Note that if no bounding box information is available, setting
+/// `use_image_if_no_bounding_boxes = true` will assume there is a single implicit
+/// bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is
+/// false and no bounding boxes are supplied, an error is raised.
+///
+/// - Parameters:
+///     - image_size: 1-D, containing `[height, width, channels]`.
+///     - bounding_boxes: 3-D with shape `[batch, N, 4]` describing the N bounding boxes
+///         associated with the image.
+///
+/// - Attrs:
+///     - seed: If either `seed` or `seed2` are set to non-zero, the random number
+///         generator is seeded by the given `seed`.  Otherwise, it is seeded by a random
+///         seed.
+///     - seed2: A second seed to avoid seed collision.
+///     - min_object_covered: The cropped area of the image must contain at least this
+///         fraction of any bounding box supplied. The value of this parameter should be
+///         non-negative. In the case of 0, the cropped area does not need to overlap
+///         any of the bounding boxes supplied.
+///     - aspect_ratio_range: The cropped area of the image must have an aspect ratio =
+///         width / height within this range.
+///     - area_range: The cropped area of the image must contain a fraction of the
+///         supplied image within this range.
+///     - max_attempts: Number of attempts at generating a cropped region of the image
+///         of the specified constraints. After `max_attempts` failures, return the entire
+///         image.
+///     - use_image_if_no_bounding_boxes: Controls behavior if no bounding boxes supplied.
+///         If true, assume an implicit bounding box covering the whole input. If false,
+///         raise an error.
+///
+/// - Outputs:
+///     - begin: 1-D, containing `[offset_height, offset_width, 0]`. Provide as input to
+///         `tf.slice`.
+///     - size: 1-D, containing `[target_height, target_width, -1]`. Provide as input to
+///         `tf.slice`.
+///     - bboxes: 3-D with shape `[1, 1, 4]` containing the distorted bounding box.
+///         Provide as input to `tf.image.draw_bounding_boxes`.
+@inlinable @inline(__always)
+public static func sampleDistortedBoundingBox<T: BinaryInteger & TensorFlowScalar>(
+    imageSize: Tensor<T>,
+    boundingBoxes: Tensor<Float>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0,
+    minObjectCovered: Double = 0.1,
+    aspectRatioRange: [Double] = [0.75, 1.33],
+    areaRange: [Double] = [0.05, 1],
+    maxAttempts: Int64 = 100,
+    useImageIfNoBoundingBoxes: Bool = false
+) -> (begin: Tensor<T>, size: Tensor<T>, bboxes: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("SampleDistortedBoundingBox", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("min_object_covered", minObjectCovered)
+    op.updateAttribute("aspect_ratio_range", aspectRatioRange)
+    op.updateAttribute("area_range", areaRange)
+    op.updateAttribute("max_attempts", maxAttempts)
+    op.updateAttribute("use_image_if_no_bounding_boxes", useImageIfNoBoundingBoxes)
+    op.addInput(imageSize)
+    op.addInput(boundingBoxes)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Generate a single randomly distorted bounding box for an image.
+///
+/// Bounding box annotations are often supplied in addition to ground-truth labels
+/// in image recognition or object localization tasks. A common technique for
+/// training such a system is to randomly distort an image while preserving
+/// its content, i.e. *data augmentation*. This Op outputs a randomly distorted
+/// localization of an object, i.e. bounding box, given an `image_size`,
+/// `bounding_boxes` and a series of constraints.
+///
+/// The output of this Op is a single bounding box that may be used to crop the
+/// original image. The output is returned as 3 tensors: `begin`, `size` and
+/// `bboxes`. The first 2 tensors can be fed directly into `tf.slice` to crop the
+/// image. The latter may be supplied to `tf.image.draw_bounding_boxes` to visualize
+/// what the bounding box looks like.
+///
+/// Bounding boxes are supplied and returned as `[y_min, x_min, y_max, x_max]`. The
+/// bounding box coordinates are floats in `[0.0, 1.0]` relative to the width and
+/// height of the underlying image.
+///
+/// For example,
+///
+/// ```python
+///     # Generate a single distorted bounding box.
+///     begin, size, bbox_for_draw = tf.image.sample_distorted_bounding_box(
+///         tf.shape(image),
+///         bounding_boxes=bounding_boxes)
+///
+///     # Draw the bounding box in an image summary.
+///     image_with_box = tf.image.draw_bounding_boxes(tf.expand_dims(image, 0),
+///                                                   bbox_for_draw)
+///     tf.summary.image('images_with_box', image_with_box)
+///
+///     # Employ the bounding box to distort the image.
+///     distorted_image = tf.slice(image, begin, size)
+/// ```
+///
+/// Note that if no bounding box information is available, setting
+/// `use_image_if_no_bounding_boxes = true` will assume there is a single implicit
+/// bounding box covering the whole image. If `use_image_if_no_bounding_boxes` is
+/// false and no bounding boxes are supplied, an error is raised.
+///
+/// - Parameters:
+///     - image_size: 1-D, containing `[height, width, channels]`.
+///     - bounding_boxes: 3-D with shape `[batch, N, 4]` describing the N bounding boxes
+///         associated with the image.
+///     - min_object_covered: The cropped area of the image must contain at least this
+///         fraction of any bounding box supplied. The value of this parameter should be
+///         non-negative. In the case of 0, the cropped area does not need to overlap
+///         any of the bounding boxes supplied.
+///
+/// - Attrs:
+///     - seed: If either `seed` or `seed2` are set to non-zero, the random number
+///         generator is seeded by the given `seed`.  Otherwise, it is seeded by a random
+///         seed.
+///     - seed2: A second seed to avoid seed collision.
+///     - aspect_ratio_range: The cropped area of the image must have an aspect ratio =
+///         width / height within this range.
+///     - area_range: The cropped area of the image must contain a fraction of the
+///         supplied image within this range.
+///     - max_attempts: Number of attempts at generating a cropped region of the image
+///         of the specified constraints. After `max_attempts` failures, return the entire
+///         image.
+///     - use_image_if_no_bounding_boxes: Controls behavior if no bounding boxes supplied.
+///         If true, assume an implicit bounding box covering the whole input. If false,
+///         raise an error.
+///
+/// - Outputs:
+///     - begin: 1-D, containing `[offset_height, offset_width, 0]`. Provide as input to
+///         `tf.slice`.
+///     - size: 1-D, containing `[target_height, target_width, -1]`. Provide as input to
+///         `tf.slice`.
+///     - bboxes: 3-D with shape `[1, 1, 4]` containing the distorted bounding box.
+///         Provide as input to `tf.image.draw_bounding_boxes`.
+@inlinable @inline(__always)
+public static func sampleDistortedBoundingBoxV2<T: BinaryInteger & TensorFlowScalar>(
+    imageSize: Tensor<T>,
+    boundingBoxes: Tensor<Float>,
+    minObjectCovered: Tensor<Float>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0,
+    aspectRatioRange: [Double] = [0.75, 1.33],
+    areaRange: [Double] = [0.05, 1],
+    maxAttempts: Int64 = 100,
+    useImageIfNoBoundingBoxes: Bool = false
+) -> (begin: Tensor<T>, size: Tensor<T>, bboxes: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("SampleDistortedBoundingBoxV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("aspect_ratio_range", aspectRatioRange)
+    op.updateAttribute("area_range", areaRange)
+    op.updateAttribute("max_attempts", maxAttempts)
+    op.updateAttribute("use_image_if_no_bounding_boxes", useImageIfNoBoundingBoxes)
+    op.addInput(imageSize)
+    op.addInput(boundingBoxes)
+    op.addInput(minObjectCovered)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Creates a dataset that contains `rate` elements from the `input_dataset`.
+///
+/// - Parameters:
+///     - rate: A scalar representing the sample rate of elements from the `input_dataset`
+///         that should be taken.
+///     - seed: A scalar representing seed of random number generator.
+///     - seed2: A scalar representing seed2 of random number generator.
+@inlinable @inline(__always)
+public static func samplingDataset(
+    inputDataset: VariantHandle,
+    rate: Tensor<Float>,
+    seed: Tensor<Int64>,
+    seed2: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("SamplingDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(rate)
+    op.addInput(seed)
+    op.addInput(seed2)
+    return op.execute(Int(1))
+}
+
+/// Saves the input tensors to disk.
+///
+/// The size of `tensor_names` must match the number of tensors in `data`. `data[i]`
+/// is written to `filename` with name `tensor_names[i]`.
+///
+/// See also `SaveSlices`.
+///
+/// - Parameters:
+///     - filename: Must have a single element. The name of the file to which we write
+///         the tensor.
+///     - tensor_names: Shape `[N]`. The names of the tensors to be saved.
+///     - data: `N` tensors to save.
+@inlinable @inline(__always)
+public static func save<T: TensorArrayProtocol>(
+    filename: StringTensor,
+    tensorNames: StringTensor,
+    data: T
+) {
+  let nOutputs = 0
+    let op = makeOp("Save", nOutputs)
+    op.updateAttribute("T", data._typeList)
+    op.addInput(filename)
+    op.addInput(tensorNames)
+    op.addInputList(data)
+    op.execute()
+}
+
+/// Saves input tensors slices to disk.
+///
+/// This is like `Save` except that tensors can be listed in the saved file as being
+/// a slice of a larger tensor.  `shapes_and_slices` specifies the shape of the
+/// larger tensor and the slice that this tensor covers. `shapes_and_slices` must
+/// have as many elements as `tensor_names`.
+///
+/// Elements of the `shapes_and_slices` input must either be:
+///
+/// *  The empty string, in which case the corresponding tensor is
+///    saved normally.
+/// *  A string of the form `dim0 dim1 ... dimN-1 slice-spec` where the
+///    `dimI` are the dimensions of the larger tensor and `slice-spec`
+///    specifies what part is covered by the tensor to save.
+///
+/// `slice-spec` itself is a `:`-separated list: `slice0:slice1:...:sliceN-1`
+/// where each `sliceI` is either:
+///
+/// *  The string `-` meaning that the slice covers all indices of this dimension
+/// *  `start,length` where `start` and `length` are integers.  In that
+///    case the slice covers `length` indices starting at `start`.
+///
+/// See also `Save`.
+///
+/// - Parameters:
+///     - filename: Must have a single element. The name of the file to which we write the
+///         tensor.
+///     - tensor_names: Shape `[N]`. The names of the tensors to be saved.
+///     - shapes_and_slices: Shape `[N]`.  The shapes and slice specifications to use when
+///         saving the tensors.
+///     - data: `N` tensors to save.
+@inlinable @inline(__always)
+public static func saveSlices<T: TensorArrayProtocol>(
+    filename: StringTensor,
+    tensorNames: StringTensor,
+    shapesAndSlices: StringTensor,
+    data: T
+) {
+  let nOutputs = 0
+    let op = makeOp("SaveSlices", nOutputs)
+    op.updateAttribute("T", data._typeList)
+    op.addInput(filename)
+    op.addInput(tensorNames)
+    op.addInput(shapesAndSlices)
+    op.addInputList(data)
+    op.execute()
+}
+
+/// Saves tensors in V2 checkpoint format.
+///
+/// By default, saves the named tensors in full.  If the caller wishes to save
+/// specific slices of full tensors, "shape_and_slices" should be non-empty strings
+/// and correspondingly well-formed.
+///
+/// - Parameters:
+///     - prefix: Must have a single element. The prefix of the V2 checkpoint to which we
+///         write the tensors.
+///     - tensor_names: shape {N}. The names of the tensors to be saved.
+///     - shape_and_slices: shape {N}.  The slice specs of the tensors to be saved.
+///         Empty strings indicate that they are non-partitioned tensors.
+///     - tensors: `N` tensors to save.
+@inlinable @inline(__always)
+public static func saveV2<Dtypes: TensorArrayProtocol>(
+    prefix: StringTensor,
+    tensorNames: StringTensor,
+    shapeAndSlices: StringTensor,
+    tensors: Dtypes
+) {
+  let nOutputs = 0
+    let op = makeOp("SaveV2", nOutputs)
+    op.updateAttribute("dtypes", tensors._typeList)
+    op.addInput(prefix)
+    op.addInput(tensorNames)
+    op.addInput(shapeAndSlices)
+    op.addInputList(tensors)
+    op.execute()
+}
+
+/// Outputs a `Summary` protocol buffer with scalar values.
+///
+/// The input `tags` and `values` must have the same shape.  The generated summary
+/// has a summary value for each tag-value pair in `tags` and `values`.
+///
+/// - Parameters:
+///     - tags: Tags for the summary.
+///     - values: Same shape as `tags.  Values for the summary.
+///
+/// - Output summary: Scalar.  Serialized `Summary` protocol buffer.
+@inlinable @inline(__always)
+public static func scalarSummary<T: Numeric & TensorFlowScalar>(
+    tags: StringTensor,
+    _ values: Tensor<T>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("ScalarSummary", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(tags)
+    op.addInput(values)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func scaleAndTranslate<T: Numeric & TensorFlowScalar>(
+    images: Tensor<T>,
+    size: Tensor<Int32>,
+    scale: Tensor<Float>,
+    translation: Tensor<Float>,
+    kernelType: String = "lanczos3",
+    antialias: Bool = true
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("ScaleAndTranslate", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("kernel_type", kernelType)
+    op.updateAttribute("antialias", antialias)
+    op.addInput(images)
+    op.addInput(size)
+    op.addInput(scale)
+    op.addInput(translation)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func scaleAndTranslateGrad<T: FloatingPoint & TensorFlowScalar>(
+    grads: Tensor<T>,
+    originalImage: Tensor<T>,
+    scale: Tensor<Float>,
+    translation: Tensor<Float>,
+    kernelType: String = "lanczos3",
+    antialias: Bool = true
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ScaleAndTranslateGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("kernel_type", kernelType)
+    op.updateAttribute("antialias", antialias)
+    op.addInput(grads)
+    op.addInput(originalImage)
+    op.addInput(scale)
+    op.addInput(translation)
+    return op.execute(Int(1))
+}
+
+/// Scatter `updates` into a new tensor according to `indices`.
+///
+/// Creates a new tensor by applying sparse `updates` to individual values or
+/// slices within a tensor (initially zero for numeric, empty for string) of
+/// the given `shape` according to indices.  This operator is the inverse of the
+/// `tf.gather_nd` operator which extracts values or slices from a given tensor.
+///
+/// This operation is similar to tensor_scatter_add, except that the tensor is
+/// zero-initialized. Calling `tf.scatter_nd(indices, values, shape)` is identical
+/// to `tensor_scatter_add(tf.zeros(shape, values.dtype), indices, values)`
+///
+/// If `indices` contains duplicates, then their updates are accumulated (summed).
+///
+/// **WARNING**: The order in which updates are applied is nondeterministic, so the
+/// output will be nondeterministic if `indices` contains duplicates -- because
+/// of some numerical approximation issues, numbers summed in different order
+/// may yield different results.
+///
+/// `indices` is an integer tensor containing indices into a new tensor of shape
+/// `shape`.  The last dimension of `indices` can be at most the rank of `shape`:
+///
+///     indices.shape[-1] <= shape.rank
+///
+/// The last dimension of `indices` corresponds to indices into elements
+/// (if `indices.shape[-1] = shape.rank`) or slices
+/// (if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
+/// `shape`.  `updates` is a tensor with shape
+///
+///     indices.shape[:-1] + shape[indices.shape[-1]:]
+///
+/// The simplest form of scatter is to insert individual elements in a tensor by
+/// index. For example, say we want to insert 4 scattered elements in a rank-1
+/// tensor with 8 elements.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd1.png" alt>
+/// </div>
+///
+/// In Python, this scatter operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[4], [3], [1], [7]])
+///     updates = tf.constant([9, 10, 11, 12])
+///     shape = tf.constant([8])
+///     scatter = tf.scatter_nd(indices, updates, shape)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [0, 11, 0, 10, 9, 0, 0, 12]
+///
+/// We can also, insert entire slices of a higher rank tensor all at once. For
+/// example, if we wanted to insert two slices in the first dimension of a
+/// rank-3 tensor with two matrices of new values.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd2.png" alt>
+/// </div>
+///
+/// In Python, this scatter operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[0], [2]])
+///     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]],
+///                            [[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]]])
+///     shape = tf.constant([4, 4, 4])
+///     scatter = tf.scatter_nd(indices, updates, shape)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+///      [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
+///      [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+///      [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]]
+///
+/// Note that on CPU, if an out of bound index is found, an error is returned.
+/// On GPU, if an out of bound index is found, the index is ignored.
+///
+/// - Parameters:
+///     - indices: Index tensor.
+///     - updates: Updates to scatter into output.
+///     - shape: 1-D. The shape of the resulting tensor.
+///
+/// - Output output: A new tensor with the given shape and updates applied according
+///     to the indices.
+@inlinable @inline(__always)
+public static func scatterNd<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    indices: Tensor<Tindices>,
+    updates: Tensor<T>,
+    shape: Tensor<Tindices>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ScatterNd", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(indices)
+    op.addInput(updates)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Applies sparse addition to `input` using individual values or slices
+///
+/// from `updates` according to indices `indices`.  The updates are non-aliasing:
+/// `input` is only modified in-place if no other operations will use it.
+/// Otherwise, a copy of `input` is made.  This operation has a gradient with
+/// respect to both `input` and `updates`.
+///
+/// `input` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
+///
+/// `indices` must be integer tensor, containing indices into `input`.
+/// It must be shape \\([d_0, ..., d_{Q-2}, K]\\) where `0 < K <= P`.
+///
+/// The innermost dimension of `indices` (with length `K`) corresponds to
+/// indices into elements (if `K = P`) or `(P-K)`-dimensional slices
+/// (if `K < P`) along the `K`th dimension of `input`.
+///
+/// `updates` is `Tensor` of rank `Q-1+P-K` with shape:
+///
+/// $$[d_0, ..., d_{Q-2}, input.shape[K], ..., input.shape[P-1]].$$
+///
+/// For example, say we want to add 4 scattered elements to a rank-1 tensor to 8
+/// elements. In Python, that addition would look like this:
+///
+///     input = tf.constant([1, 2, 3, 4, 5, 6, 7, 8])
+///     indices = tf.constant([[4], [3], [1], [7]])
+///     updates = tf.constant([9, 10, 11, 12])
+///     output = tf.scatter_nd_non_aliasing_add(input, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(output))
+///
+/// The resulting value `output` would look like this:
+///
+///     [1, 13, 3, 14, 14, 6, 7, 20]
+///
+/// See `tf.scatter_nd` for more details about how to make updates to slices.
+///
+/// - Parameters:
+///     - input: A Tensor.
+///     - indices: A Tensor. Must be one of the following types: `int32`, `int64`.
+///         A tensor of indices into `input`.
+///     - updates: A Tensor. Must have the same type as ref. A tensor of updated values
+///         to add to `input`.
+///
+/// - Output output: A `Tensor` with the same shape as `input`, containing values of `input`
+///     updated with `updates`.
+@inlinable @inline(__always)
+public static func scatterNdNonAliasingAdd<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    indices: Tensor<Tindices>,
+    updates: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ScatterNdNonAliasingAdd", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(indices)
+    op.addInput(updates)
+    return op.execute(Int(1))
+}
+
+/// Computes fingerprints of the input strings.
+///
+/// - Parameter input: vector of strings to compute fingerprints on.
+///
+/// - Output output: a (N,2) shaped matrix where N is the number of elements in the input
+///     vector. Each row contains the low and high parts of the fingerprint.
+@inlinable @inline(__always)
+public static func sdcaFprint(
+    _ input: StringTensor
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("SdcaFprint", nOutputs)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Distributed version of Stochastic Dual Coordinate Ascent (SDCA) optimizer for
+///
+/// linear models with L1 + L2 regularization. As global optimization objective is
+/// strongly-convex, the optimizer optimizes the dual objective at each step. The
+/// optimizer applies each update one example at a time. Examples are sampled
+/// uniformly, and the optimizer is learning rate free and enjoys linear convergence
+/// rate.
+///
+/// [Proximal Stochastic Dual Coordinate Ascent](http://arxiv.org/pdf/1211.2717v1.pdf).<br>
+/// Shai Shalev-Shwartz, Tong Zhang. 2012
+///
+/// $$Loss Objective = \sum f_{i} (wx_{i}) + (l2 / 2) * |w|^2 + l1 * |w|$$
+///
+/// [Adding vs. Averaging in Distributed Primal-Dual Optimization](http://arxiv.org/abs/1502.03508).<br>
+/// Chenxin Ma, Virginia Smith, Martin Jaggi, Michael I. Jordan,
+/// Peter Richtarik, Martin Takac. 2015
+///
+/// [Stochastic Dual Coordinate Ascent with Adaptive Probabilities](https://arxiv.org/abs/1502.08053).<br>
+/// Dominik Csiba, Zheng Qu, Peter Richtarik. 2015
+///
+/// - Parameters:
+///     - sparse_example_indices: a list of vectors which contain example indices.
+///     - sparse_feature_indices: a list of vectors which contain feature indices.
+///     - sparse_feature_values: a list of vectors which contains feature value
+///         associated with each feature group.
+///     - dense_features: a list of matrices which contains the dense feature values.
+///     - example_weights: a vector which contains the weight associated with each
+///         example.
+///     - example_labels: a vector which contains the label/target associated with each
+///         example.
+///     - sparse_indices: a list of vectors where each value is the indices which has
+///         corresponding weights in sparse_weights. This field maybe omitted for the
+///         dense approach.
+///     - sparse_weights: a list of vectors where each value is the weight associated with
+///         a sparse feature group.
+///     - dense_weights: a list of vectors where the values are the weights associated
+///         with a dense feature group.
+///     - example_state_data: a list of vectors containing the example state data.
+///
+/// - Attrs:
+///     - loss_type: Type of the primal loss. Currently SdcaSolver supports logistic,
+///         squared and hinge losses.
+///     - adaptative: Whether to use Adaptive SDCA for the inner loop.
+///     - num_sparse_features: Number of sparse feature groups to train on.
+///     - num_sparse_features_with_values: Number of sparse feature groups with values
+///         associated with it, otherwise implicitly treats values as 1.0.
+///     - num_dense_features: Number of dense feature groups to train on.
+///     - l1: Symmetric l1 regularization strength.
+///     - l2: Symmetric l2 regularization strength.
+///     - num_loss_partitions: Number of partitions of the global loss function.
+///     - num_inner_iterations: Number of iterations per mini-batch.
+///
+/// - Outputs:
+///     - out_example_state_data: a list of vectors containing the updated example state
+///         data.
+///     - out_delta_sparse_weights: a list of vectors where each value is the delta
+///         weights associated with a sparse feature group.
+///     - out_delta_dense_weights: a list of vectors where the values are the delta
+///         weights associated with a dense feature group.
+@inlinable @inline(__always)
+public static func sdcaOptimizer(
+    sparseExampleIndices: [Tensor<Int64>],
+    sparseFeatureIndices: [Tensor<Int64>],
+    sparseFeatureValues: [Tensor<Float>],
+    denseFeatures: [Tensor<Float>],
+    exampleWeights: Tensor<Float>,
+    exampleLabels: Tensor<Float>,
+    sparseIndices: [Tensor<Int64>],
+    sparseWeights: [Tensor<Float>],
+    denseWeights: [Tensor<Float>],
+    exampleStateData: Tensor<Float>,
+    lossType: LossType,
+    adaptative: Bool = false,
+    l1: Double,
+    l2: Double,
+    numLossPartitions: Int64,
+    numInnerIterations: Int64
+) -> (outExampleStateData: Tensor<Float>, outDeltaSparseWeights: [Tensor<Float>], outDeltaDenseWeights: [Tensor<Float>]) {
+  let nOutputs = Int(1) + Int(sparseExampleIndices.count) + Int(denseFeatures.count)
+    let op = makeOp("SdcaOptimizer", nOutputs)
+    op.updateAttribute("loss_type", lossType.cName)
+    op.updateAttribute("adaptative", adaptative)
+    op.updateAttribute("num_sparse_features", sparseExampleIndices.count)
+    op.updateAttribute("num_sparse_features_with_values", sparseFeatureValues.count)
+    op.updateAttribute("num_dense_features", denseFeatures.count)
+    op.updateAttribute("l1", l1)
+    op.updateAttribute("l2", l2)
+    op.updateAttribute("num_loss_partitions", numLossPartitions)
+    op.updateAttribute("num_inner_iterations", numInnerIterations)
+    op.addInputList(sparseExampleIndices)
+    op.addInputList(sparseFeatureIndices)
+    op.addInputList(sparseFeatureValues)
+    op.addInputList(denseFeatures)
+    op.addInput(exampleWeights)
+    op.addInput(exampleLabels)
+    op.addInputList(sparseIndices)
+    op.addInputList(sparseWeights)
+    op.addInputList(denseWeights)
+    op.addInput(exampleStateData)
+    return op.execute(Int(1), Int(sparseExampleIndices.count), Int(denseFeatures.count))
+}
+
+/// Distributed version of Stochastic Dual Coordinate Ascent (SDCA) optimizer for
+///
+/// linear models with L1 + L2 regularization. As global optimization objective is
+/// strongly-convex, the optimizer optimizes the dual objective at each step. The
+/// optimizer applies each update one example at a time. Examples are sampled
+/// uniformly, and the optimizer is learning rate free and enjoys linear convergence
+/// rate.
+///
+/// [Proximal Stochastic Dual Coordinate Ascent](http://arxiv.org/pdf/1211.2717v1.pdf).<br>
+/// Shai Shalev-Shwartz, Tong Zhang. 2012
+///
+/// $$Loss Objective = \sum f_{i} (wx_{i}) + (l2 / 2) * |w|^2 + l1 * |w|$$
+///
+/// [Adding vs. Averaging in Distributed Primal-Dual Optimization](http://arxiv.org/abs/1502.03508).<br>
+/// Chenxin Ma, Virginia Smith, Martin Jaggi, Michael I. Jordan,
+/// Peter Richtarik, Martin Takac. 2015
+///
+/// [Stochastic Dual Coordinate Ascent with Adaptive Probabilities](https://arxiv.org/abs/1502.08053).<br>
+/// Dominik Csiba, Zheng Qu, Peter Richtarik. 2015
+///
+/// - Parameters:
+///     - sparse_example_indices: a list of vectors which contain example indices.
+///     - sparse_feature_indices: a list of vectors which contain feature indices.
+///     - sparse_feature_values: a list of vectors which contains feature value
+///         associated with each feature group.
+///     - dense_features: a list of matrices which contains the dense feature values.
+///     - example_weights: a vector which contains the weight associated with each
+///         example.
+///     - example_labels: a vector which contains the label/target associated with each
+///         example.
+///     - sparse_indices: a list of vectors where each value is the indices which has
+///         corresponding weights in sparse_weights. This field maybe omitted for the
+///         dense approach.
+///     - sparse_weights: a list of vectors where each value is the weight associated with
+///         a sparse feature group.
+///     - dense_weights: a list of vectors where the values are the weights associated
+///         with a dense feature group.
+///     - example_state_data: a list of vectors containing the example state data.
+///
+/// - Attrs:
+///     - loss_type: Type of the primal loss. Currently SdcaSolver supports logistic,
+///         squared and hinge losses.
+///     - adaptive: Whether to use Adaptive SDCA for the inner loop.
+///     - num_sparse_features: Number of sparse feature groups to train on.
+///     - num_sparse_features_with_values: Number of sparse feature groups with values
+///         associated with it, otherwise implicitly treats values as 1.0.
+///     - num_dense_features: Number of dense feature groups to train on.
+///     - l1: Symmetric l1 regularization strength.
+///     - l2: Symmetric l2 regularization strength.
+///     - num_loss_partitions: Number of partitions of the global loss function.
+///     - num_inner_iterations: Number of iterations per mini-batch.
+///
+/// - Outputs:
+///     - out_example_state_data: a list of vectors containing the updated example state
+///         data.
+///     - out_delta_sparse_weights: a list of vectors where each value is the delta
+///         weights associated with a sparse feature group.
+///     - out_delta_dense_weights: a list of vectors where the values are the delta
+///         weights associated with a dense feature group.
+@inlinable @inline(__always)
+public static func sdcaOptimizerV2(
+    sparseExampleIndices: [Tensor<Int64>],
+    sparseFeatureIndices: [Tensor<Int64>],
+    sparseFeatureValues: [Tensor<Float>],
+    denseFeatures: [Tensor<Float>],
+    exampleWeights: Tensor<Float>,
+    exampleLabels: Tensor<Float>,
+    sparseIndices: [Tensor<Int64>],
+    sparseWeights: [Tensor<Float>],
+    denseWeights: [Tensor<Float>],
+    exampleStateData: Tensor<Float>,
+    lossType: LossType,
+    adaptive: Bool = false,
+    l1: Double,
+    l2: Double,
+    numLossPartitions: Int64,
+    numInnerIterations: Int64
+) -> (outExampleStateData: Tensor<Float>, outDeltaSparseWeights: [Tensor<Float>], outDeltaDenseWeights: [Tensor<Float>]) {
+  let nOutputs = Int(1) + Int(sparseExampleIndices.count) + Int(denseFeatures.count)
+    let op = makeOp("SdcaOptimizerV2", nOutputs)
+    op.updateAttribute("loss_type", lossType.cName)
+    op.updateAttribute("adaptive", adaptive)
+    op.updateAttribute("num_sparse_features", sparseExampleIndices.count)
+    op.updateAttribute("num_sparse_features_with_values", sparseFeatureValues.count)
+    op.updateAttribute("num_dense_features", denseFeatures.count)
+    op.updateAttribute("l1", l1)
+    op.updateAttribute("l2", l2)
+    op.updateAttribute("num_loss_partitions", numLossPartitions)
+    op.updateAttribute("num_inner_iterations", numInnerIterations)
+    op.addInputList(sparseExampleIndices)
+    op.addInputList(sparseFeatureIndices)
+    op.addInputList(sparseFeatureValues)
+    op.addInputList(denseFeatures)
+    op.addInput(exampleWeights)
+    op.addInput(exampleLabels)
+    op.addInputList(sparseIndices)
+    op.addInputList(sparseWeights)
+    op.addInputList(denseWeights)
+    op.addInput(exampleStateData)
+    return op.execute(Int(1), Int(sparseExampleIndices.count), Int(denseFeatures.count))
+}
+
+/// Computes the maximum along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Computes a tensor such that
+/// \\(output_i = \max_j(data_j)\\) where `max` is over `j` such
+/// that `segment_ids[j] == i`.
+///
+/// If the max is empty for a given segment ID `i`, `output[i] = 0`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentMax.png" alt>
+/// </div>
+///
+/// For example:
+///
+/// ```
+/// c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
+/// tf.segment_max(c, tf.constant([0, 0, 1]))
+/// # ==> [[4, 3, 3, 4],
+/// #      [5, 6, 7, 8]]
+/// ```
+///
+///
+/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
+///     first dimension.  Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///     has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func segmentMax<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    segmentIds: Tensor<Tindices>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SegmentMax", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(segmentIds)
+    return op.execute(Int(1))
+}
+
+/// Computes the mean along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Computes a tensor such that
+/// \\(output_i = \frac{\sum_j data_j}{N}\\) where `mean` is
+/// over `j` such that `segment_ids[j] == i` and `N` is the total number of
+/// values summed.
+///
+/// If the mean is empty for a given segment ID `i`, `output[i] = 0`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentMean.png" alt>
+/// </div>
+///
+/// For example:
+///
+/// ```
+/// c = tf.constant([[1.0,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
+/// tf.segment_mean(c, tf.constant([0, 0, 1]))
+/// # ==> [[2.5, 2.5, 2.5, 2.5],
+/// #      [5, 6, 7, 8]]
+/// ```
+///
+///
+/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
+///     first dimension.  Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///     has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func segmentMean<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    segmentIds: Tensor<Tindices>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SegmentMean", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(segmentIds)
+    return op.execute(Int(1))
+}
+
+/// Computes the minimum along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Computes a tensor such that
+/// \\(output_i = \min_j(data_j)\\) where `min` is over `j` such
+/// that `segment_ids[j] == i`.
+///
+/// If the min is empty for a given segment ID `i`, `output[i] = 0`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentMin.png" alt>
+/// </div>
+///
+/// For example:
+///
+/// ```
+/// c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
+/// tf.segment_min(c, tf.constant([0, 0, 1]))
+/// # ==> [[1, 2, 2, 1],
+/// #      [5, 6, 7, 8]]
+/// ```
+///
+/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
+///     first dimension.  Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///     has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func segmentMin<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    segmentIds: Tensor<Tindices>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SegmentMin", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(segmentIds)
+    return op.execute(Int(1))
+}
+
+/// Computes the product along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Computes a tensor such that
+/// \\(output_i = \prod_j data_j\\) where the product is over `j` such
+/// that `segment_ids[j] == i`.
+///
+/// If the product is empty for a given segment ID `i`, `output[i] = 1`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentProd.png" alt>
+/// </div>
+///
+/// For example:
+///
+/// ```
+/// c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
+/// tf.segment_prod(c, tf.constant([0, 0, 1]))
+/// # ==> [[4, 6, 6, 4],
+/// #      [5, 6, 7, 8]]
+/// ```
+///
+///
+/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
+///     first dimension.  Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///     has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func segmentProd<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    segmentIds: Tensor<Tindices>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SegmentProd", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(segmentIds)
+    return op.execute(Int(1))
+}
+
+/// Computes the sum along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Computes a tensor such that
+/// \\(output_i = \sum_j data_j\\) where sum is over `j` such
+/// that `segment_ids[j] == i`.
+///
+/// If the sum is empty for a given segment ID `i`, `output[i] = 0`.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/SegmentSum.png" alt>
+/// </div>
+///
+/// For example:
+///
+/// ```
+/// c = tf.constant([[1,2,3,4], [4, 3, 2, 1], [5,6,7,8]])
+/// tf.segment_sum(c, tf.constant([0, 0, 1]))
+/// # ==> [[5, 5, 5, 5],
+/// #      [5, 6, 7, 8]]
+/// ```
+///
+///
+/// - Parameter segment_ids: A 1-D tensor whose size is equal to the size of `data`'s
+///     first dimension.  Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///     has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func segmentSum<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    segmentIds: Tensor<Tindices>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SegmentSum", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(segmentIds)
+    return op.execute(Int(1))
+}
+
+/// Selects elements from `x` or `y`, depending on `condition`.
+///
+/// The `x`, and `y` tensors must all have the same shape, and the
+/// output will also have that shape.
+///
+/// The `condition` tensor must be a scalar if `x` and `y` are scalars.
+/// If `x` and `y` are vectors or higher rank, then `condition` must be either a
+/// scalar, a vector with size matching the first dimension of `x`, or must have
+/// the same shape as `x`.
+///
+/// The `condition` tensor acts as a mask that chooses, based on the value at each
+/// element, whether the corresponding element / row in the output should be
+/// taken from `x` (if true) or `y` (if false).
+///
+/// If `condition` is a vector and `x` and `y` are higher rank matrices, then
+/// it chooses which row (outer dimension) to copy from `x` and `y`.
+/// If `condition` has the same shape as `x` and `y`, then it chooses which
+/// element to copy from `x` and `y`.
+///
+/// For example:
+///
+/// ```python
+/// # 'condition' tensor is [[True,  False]
+/// #                        [False, True]]
+/// # 't' is [[1, 2],
+/// #         [3, 4]]
+/// # 'e' is [[5, 6],
+/// #         [7, 8]]
+/// select(condition, t, e)  # => [[1, 6], [7, 4]]
+///
+///
+/// # 'condition' tensor is [True, False]
+/// # 't' is [[1, 2],
+/// #         [3, 4]]
+/// # 'e' is [[5, 6],
+/// #         [7, 8]]
+/// select(condition, t, e) ==> [[1, 2],
+///                              [7, 8]]
+///
+/// ```
+///
+/// - Parameters:
+///     - t: = A `Tensor` which may have the same shape as `condition`.
+///         If `condition` is rank 1, `x` may have higher rank,
+///         but its first dimension must match the size of `condition`.
+///     - e: = A `Tensor` with the same type and shape as `x`.
+///
+/// - Output output: = A `Tensor` with the same type and shape as `x` and `y`.
+@inlinable @inline(__always)
+public static func select<T: TensorFlowScalar>(
+    condition: Tensor<Bool>,
+    t: Tensor<T>,
+    e: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Select", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(condition)
+    op.addInput(t)
+    op.addInput(e)
+    return op.execute(Int(1))
+}
+
+/// Computes the Eigen Decomposition of a batch of square self-adjoint matrices.
+///
+/// The input is a tensor of shape `[..., M, M]` whose inner-most 2 dimensions
+/// form square matrices, with the same constraints as the single matrix
+/// SelfAdjointEig.
+///
+/// The result is a [..., M+1, M] matrix with [..., 0,:] containing the
+/// eigenvalues, and subsequent [...,1:, :] containing the eigenvectors. The eigenvalues
+/// are sorted in non-decreasing order.
+///
+/// - Parameter input: Shape is `[..., M, M]`.
+///
+/// - Output output: Shape is `[..., M+1, M]`.
+@inlinable @inline(__always)
+public static func selfAdjointEig<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SelfAdjointEig", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Computes the eigen decomposition of one or more square self-adjoint matrices.
+///
+/// Computes the eigenvalues and (optionally) eigenvectors of each inner matrix in
+/// `input` such that `input[..., :, :] = v[..., :, :] * diag(e[..., :])`. The eigenvalues
+/// are sorted in non-decreasing order.
+///
+/// ```python
+/// # a is a tensor.
+/// # e is a tensor of eigenvalues.
+/// # v is a tensor of eigenvectors.
+/// e, v = self_adjoint_eig(a)
+/// e = self_adjoint_eig(a, compute_v=False)
+/// ```
+///
+/// - Parameter input: `Tensor` input of shape `[N, N]`.
+///
+/// - Attr compute_v: If `True` then eigenvectors will be computed and returned in `v`.
+///     Otherwise, only the eigenvalues will be computed.
+///
+/// - Outputs:
+///     - e: Eigenvalues. Shape is `[N]`.
+///     - v: Eigenvectors. Shape is `[N, N]`.
+@inlinable @inline(__always)
+public static func selfAdjointEigV2<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    computeV: Bool = true
+) -> (e: Tensor<T>, v: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("SelfAdjointEigV2", nOutputs)
+    op.updateAttribute("compute_v", computeV)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Computes scaled exponential linear: `scale * alpha * (exp(features) - 1)`
+///
+/// if < 0, `scale * features` otherwise.
+///
+/// To be used together with
+/// `initializer = tf.variance_scaling_initializer(factor=1.0, mode='FAN_IN')`.
+/// For correct dropout, use `tf.contrib.nn.alpha_dropout`.
+///
+/// See [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)
+@inlinable @inline(__always)
+public static func selu<T: FloatingPoint & TensorFlowScalar>(
+    features: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Selu", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(features)
+    return op.execute(Int(1))
+}
+
+/// Computes gradients for the scaled exponential linear (Selu) operation.
+///
+/// - Parameters:
+///     - gradients: The backpropagated gradients to the corresponding Selu operation.
+///     - outputs: The outputs of the corresponding Selu operation.
+///
+/// - Output backprops: The gradients: `gradients * (outputs + scale * alpha)`
+///     if outputs < 0, `scale * gradients` otherwise.
+@inlinable @inline(__always)
+public static func seluGrad<T: FloatingPoint & TensorFlowScalar>(
+    gradients: Tensor<T>,
+    outputs: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SeluGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(gradients)
+    op.addInput(outputs)
+    return op.execute(Int(1))
+}
+
+/// Performs gradient updates of embedding tables.
+///
+/// - Parameters:
+///     - inputs: A TensorList of gradients with which to update embedding tables.
+///         This argument has the same length and shapes as the return value of
+///         RecvTPUEmbeddingActivations, but contains gradients of the model's loss
+///         with respect to the embedding activations. The embedding tables are updated
+///         from these gradients via the optimizer specified in the TPU embedding
+///         configuration given to tpu.initialize_system.
+///     - learning_rates: A TensorList of float32 scalars, one for each dynamic learning
+///         rate tag: see the comments in
+///         //third_party/tensorflow/core/protobuf/tpu/optimization_parameters.proto.
+///         Multiple tables can share the same dynamic learning rate tag as specified
+///         in the configuration. If the learning rates for all tables are constant,
+///         this list should be empty.
+///
+/// - Attr config: Serialized TPUEmbeddingConfiguration proto.
+@inlinable @inline(__always)
+public static func sendTPUEmbeddingGradients(
+    inputs: [Tensor<Float>],
+    learningRates: [Tensor<Float>],
+    config: String
+) {
+  let nOutputs = 0
+    let op = makeOp("SendTPUEmbeddingGradients", nOutputs)
+    op.updateAttribute("N", inputs.count)
+    op.updateAttribute("NN", learningRates.count)
+    op.updateAttribute("config", config)
+    op.addInputList(inputs)
+    op.addInputList(learningRates)
+    op.execute()
+}
+
+/// Converts the given `resource_handle` representing an iterator to a variant tensor.
+///
+/// - Parameter resource_handle: A handle to an iterator resource.
+///
+/// - Output serialized: A variant tensor storing the state of the iterator contained in the
+///     resource.
+@inlinable @inline(__always)
+public static func serializeIterator(
+    resourceHandle: ResourceHandle
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("SerializeIterator", nOutputs)
+    op.addInput(resourceHandle)
+    return op.execute(Int(1))
+}
+
+/// Serialize an `N`-minibatch `SparseTensor` into an `[N, 3]` `Tensor` object.
+///
+/// The `SparseTensor` must have rank `R` greater than 1, and the first dimension
+/// is treated as the minibatch dimension.  Elements of the `SparseTensor`
+/// must be sorted in increasing order of this first dimension.  The serialized
+/// `SparseTensor` objects going into each row of `serialized_sparse` will have
+/// rank `R-1`.
+///
+/// The minibatch size `N` is extracted from `sparse_shape[0]`.
+///
+/// - Parameters:
+///     - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
+///     - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
+///     - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
+///
+/// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
+///     (default) and `variant`.
+@inlinable @inline(__always)
+public static func serializeManySparse<
+    T: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    sparseIndices: Tensor<Int64>,
+    sparseValues: Tensor<T>,
+    sparseShape: Tensor<Int64>
+) -> Tensor<OutType> {
+  let nOutputs = Int(1)
+    let op = makeOp("SerializeManySparse", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(sparseIndices)
+    op.addInput(sparseValues)
+    op.addInput(sparseShape)
+    return op.execute(Int(1))
+}
+
+/// Serialize an `N`-minibatch `SparseTensor` into an `[N, 3]` `Tensor` object.
+///
+/// The `SparseTensor` must have rank `R` greater than 1, and the first dimension
+/// is treated as the minibatch dimension.  Elements of the `SparseTensor`
+/// must be sorted in increasing order of this first dimension.  The serialized
+/// `SparseTensor` objects going into each row of `serialized_sparse` will have
+/// rank `R-1`.
+///
+/// The minibatch size `N` is extracted from `sparse_shape[0]`.
+///
+/// - Parameters:
+///     - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
+///     - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
+///     - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
+///
+/// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
+///     (default) and `variant`.
+@inlinable @inline(__always)
+public static func serializeManySparse<T: TensorFlowScalar>(
+    sparseIndices: Tensor<Int64>,
+    sparseValues: Tensor<T>,
+    sparseShape: Tensor<Int64>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("SerializeManySparse", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_type", TensorDataType(TF_STRING))
+    op.addInput(sparseIndices)
+    op.addInput(sparseValues)
+    op.addInput(sparseShape)
+    return op.execute(Int(1))
+}
+
+/// Serialize a `SparseTensor` into a `[3]` `Tensor` object.
+///
+/// - Parameters:
+///     - sparse_indices: 2-D.  The `indices` of the `SparseTensor`.
+///     - sparse_values: 1-D.  The `values` of the `SparseTensor`.
+///     - sparse_shape: 1-D.  The `shape` of the `SparseTensor`.
+///
+/// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
+///     (default) and `variant`.
+@inlinable @inline(__always)
+public static func serializeSparse<
+    T: TensorFlowScalar,
+    OutType: TensorFlowScalar
+>(
+    sparseIndices: Tensor<Int64>,
+    sparseValues: Tensor<T>,
+    sparseShape: Tensor<Int64>
+) -> Tensor<OutType> {
+  let nOutputs = Int(1)
+    let op = makeOp("SerializeSparse", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(sparseIndices)
+    op.addInput(sparseValues)
+    op.addInput(sparseShape)
+    return op.execute(Int(1))
+}
+
+/// Serialize a `SparseTensor` into a `[3]` `Tensor` object.
+///
+/// - Parameters:
+///     - sparse_indices: 2-D.  The `indices` of the `SparseTensor`.
+///     - sparse_values: 1-D.  The `values` of the `SparseTensor`.
+///     - sparse_shape: 1-D.  The `shape` of the `SparseTensor`.
+///
+/// - Attr out_type: The `dtype` to use for serialization; the supported types are `string`
+///     (default) and `variant`.
+@inlinable @inline(__always)
+public static func serializeSparse<T: TensorFlowScalar>(
+    sparseIndices: Tensor<Int64>,
+    sparseValues: Tensor<T>,
+    sparseShape: Tensor<Int64>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("SerializeSparse", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_type", TensorDataType(TF_STRING))
+    op.addInput(sparseIndices)
+    op.addInput(sparseValues)
+    op.addInput(sparseShape)
+    return op.execute(Int(1))
+}
+
+/// Transforms a Tensor into a serialized TensorProto proto.
+///
+/// - Parameter tensor: A Tensor of type `T`.
+///
+/// - Attr T: The type of the input tensor.
+///
+/// - Output serialized: A serialized TensorProto proto of the input tensor.
+@inlinable @inline(__always)
+public static func serializeTensor<T: TensorFlowScalar>(
+    _ tensor: Tensor<T>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("SerializeTensor", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(tensor)
+    return op.execute(Int(1))
+}
+
+/// Number of unique elements along last dimension of input `set`.
+///
+/// Input `set` is a `SparseTensor` represented by `set_indices`, `set_values`,
+/// and `set_shape`. The last dimension contains values in a set, duplicates are
+/// allowed but ignored.
+///
+/// If `validate_indices` is `True`, this op validates the order and range of `set`
+/// indices.
+///
+/// - Parameters:
+///     - set_indices: 2D `Tensor`, indices of a `SparseTensor`.
+///     - set_values: 1D `Tensor`, values of a `SparseTensor`.
+///     - set_shape: 1D `Tensor`, shape of a `SparseTensor`.
+///
+/// - Output size: For `set` ranked `n`, this is a `Tensor` with rank `n-1`, and the same 1st
+///     `n-1` dimensions as `set`. Each value is the number of unique elements in
+///     the corresponding `[0...n-1]` dimension of `set`.
+@inlinable @inline(__always)
+public static func setSize<T: BinaryInteger & TensorFlowScalar>(
+    setIndices: Tensor<Int64>,
+    setValues: Tensor<T>,
+    setShape: Tensor<Int64>,
+    validateIndices: Bool = true
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("SetSize", nOutputs)
+    op.updateAttribute("validate_indices", validateIndices)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(setIndices)
+    op.addInput(setValues)
+    op.addInput(setShape)
+    return op.execute(Int(1))
+}
+
+/// Number of unique elements along last dimension of input `set`.
+///
+/// Input `set` is a `SparseTensor` represented by `set_indices`, `set_values`,
+/// and `set_shape`. The last dimension contains values in a set, duplicates are
+/// allowed but ignored.
+///
+/// If `validate_indices` is `True`, this op validates the order and range of `set`
+/// indices.
+///
+/// - Parameters:
+///     - set_indices: 2D `Tensor`, indices of a `SparseTensor`.
+///     - set_values: 1D `Tensor`, values of a `SparseTensor`.
+///     - set_shape: 1D `Tensor`, shape of a `SparseTensor`.
+///
+/// - Output size: For `set` ranked `n`, this is a `Tensor` with rank `n-1`, and the same 1st
+///     `n-1` dimensions as `set`. Each value is the number of unique elements in
+///     the corresponding `[0...n-1]` dimension of `set`.
+@inlinable @inline(__always)
+public static func setSize(
+    setIndices: Tensor<Int64>,
+    setValues: StringTensor,
+    setShape: Tensor<Int64>,
+    validateIndices: Bool = true
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("SetSize", nOutputs)
+    op.updateAttribute("validate_indices", validateIndices)
+    op.updateAttribute("T", TensorDataType(TF_STRING))
+    op.addInput(setIndices)
+    op.addInput(setValues)
+    op.addInput(setShape)
+    return op.execute(Int(1))
+}
+
+/// Returns the shape of a tensor.
+///
+/// This operation returns a 1-D integer tensor representing the shape of `input`.
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
+/// shape(t) ==> [2, 2, 3]
+/// ```
+@inlinable @inline(__always)
+public static func shape<
+    T: TensorFlowScalar,
+    OutType: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>
+) -> Tensor<OutType> {
+  let nOutputs = Int(1)
+    let op = makeOp("Shape", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Returns shape of tensors.
+///
+/// This operation returns N 1-D integer tensors representing shape of `input[i]s`.
+@inlinable @inline(__always)
+public static func shapeN<
+    T: TensorFlowScalar,
+    OutType: BinaryInteger & TensorFlowScalar
+>(
+    _ input: [Tensor<T>]
+) -> [Tensor<OutType>] {
+  let nOutputs = Int(input.count)
+    let op = makeOp("ShapeN", nOutputs)
+    op.updateAttribute("N", input.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInputList(input)
+    return op.execute(Int(input.count))
+}
+
+/// Creates a `Dataset` that includes only 1/`num_shards` of this dataset.
+///
+/// - Parameters:
+///     - num_shards: An integer representing the number of shards operating in parallel.
+///     - index: An integer representing the current worker index.
+@inlinable @inline(__always)
+public static func shardDataset(
+    inputDataset: VariantHandle,
+    numShards: Tensor<Int64>,
+    index: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ShardDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(numShards)
+    op.addInput(index)
+    return op.execute(Int(1))
+}
+
+/// Generate a sharded filename. The filename is printf formatted as
+///
+///    %s-%05d-of-%05d, basename, shard, num_shards.
+@inlinable @inline(__always)
+public static func shardedFilename(
+    basename: StringTensor,
+    shard: Tensor<Int32>,
+    numShards: Tensor<Int32>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("ShardedFilename", nOutputs)
+    op.addInput(basename)
+    op.addInput(shard)
+    op.addInput(numShards)
+    return op.execute(Int(1))
+}
+
+/// Generate a glob pattern matching all sharded file names.
+@inlinable @inline(__always)
+public static func shardedFilespec(
+    basename: StringTensor,
+    numShards: Tensor<Int32>
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("ShardedFilespec", nOutputs)
+    op.addInput(basename)
+    op.addInput(numShards)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that shuffles and repeats elements from `input_dataset`
+///
+/// pseudorandomly.
+///
+/// - Parameters:
+///     - buffer_size: The number of output elements to buffer in an iterator over
+///         this dataset. Compare with the `min_after_dequeue` attr when creating a
+///         `RandomShuffleQueue`.
+///     - seed: A scalar seed for the random number generator. If either `seed` or
+///         `seed2` is set to be non-zero, the random number generator is seeded
+///         by the given seed.  Otherwise, a random seed is used.
+///     - seed2: A second scalar seed to avoid seed collision.
+///     - count: A scalar representing the number of times the underlying dataset
+///         should be repeated. The default is `-1`, which results in infinite repetition.
+@inlinable @inline(__always)
+public static func shuffleAndRepeatDataset(
+    inputDataset: VariantHandle,
+    bufferSize: Tensor<Int64>,
+    seed: Tensor<Int64>,
+    seed2: Tensor<Int64>,
+    count: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ShuffleAndRepeatDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(bufferSize)
+    op.addInput(seed)
+    op.addInput(seed2)
+    op.addInput(count)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that shuffles elements from `input_dataset` pseudorandomly.
+///
+/// - Parameters:
+///     - buffer_size: The number of output elements to buffer in an iterator over
+///         this dataset. Compare with the `min_after_dequeue` attr when creating a
+///         `RandomShuffleQueue`.
+///     - seed: A scalar seed for the random number generator. If either `seed` or
+///         `seed2` is set to be non-zero, the random number generator is seeded
+///         by the given seed.  Otherwise, a random seed is used.
+///     - seed2: A second scalar seed to avoid seed collision.
+///
+/// - Attr reshuffle_each_iteration: If true, each iterator over this dataset will be given
+///     a different pseudorandomly generated seed, based on a sequence seeded by the
+///     `seed` and `seed2` inputs. If false, each iterator will be given the same
+///     seed, and repeated iteration over this dataset will yield the exact same
+///     sequence of results.
+@inlinable @inline(__always)
+public static func shuffleDataset(
+    inputDataset: VariantHandle,
+    bufferSize: Tensor<Int64>,
+    seed: Tensor<Int64>,
+    seed2: Tensor<Int64>,
+    reshuffleEachIteration: Bool = true,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ShuffleDataset", nOutputs)
+    op.updateAttribute("reshuffle_each_iteration", reshuffleEachIteration)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(bufferSize)
+    op.addInput(seed)
+    op.addInput(seed2)
+    return op.execute(Int(1))
+}
+
+/// Shuts down a running distributed TPU system.
+///
+/// The op returns an error if no system is running.
+@inlinable @inline(__always)
+public static func shutdownDistributedTPU(
+) {
+  let nOutputs = 0
+    let op = makeOp("ShutdownDistributedTPU", nOutputs)
+    
+    op.execute()
+}
+
+/// Computes sigmoid of `x` element-wise.
+///
+/// Specifically, `y = 1 / (1 + exp(-x))`.
+@inlinable @inline(__always)
+public static func sigmoid<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Sigmoid", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient of the sigmoid of `x` wrt its input.
+///
+/// Specifically, `grad = dy * y * (1 - y)`, where `y = sigmoid(x)`, and
+/// `dy` is the corresponding input gradient.
+@inlinable @inline(__always)
+public static func sigmoidGrad<T: FloatingPoint & TensorFlowScalar>(
+    _ y: Tensor<T>,
+    dy: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SigmoidGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(y)
+    op.addInput(dy)
+    return op.execute(Int(1))
+}
+
+/// Returns an element-wise indication of the sign of a number.
+///
+/// `y = sign(x) = -1` if `x < 0`; 0 if `x == 0`; 1 if `x > 0`.
+///
+/// For complex numbers, `y = sign(x) = x / |x|` if `x != 0`, otherwise `y = 0`.
+@inlinable @inline(__always)
+public static func sign<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Sign", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func simple(
+    _ a: Tensor<Int32>
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("Simple", nOutputs)
+    op.addInput(a)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func simpleStruct(
+    nA: Int64
+) -> [Tensor<Int32>] {
+  let nOutputs = Int(nA)
+    let op = makeOp("SimpleStruct", nOutputs)
+    op.updateAttribute("n_a", nA)
+    return op.execute(Int(nA))
+}
+
+/// Computes sin of x element-wise.
+@inlinable @inline(__always)
+public static func sin<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Sin", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes hyperbolic sine of x element-wise.
+@inlinable @inline(__always)
+public static func sinh<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Sinh", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns the size of a tensor.
+///
+/// This operation returns an integer representing the number of elements in
+/// `input`.
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[[1, 1,, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]
+/// size(t) ==> 12
+/// ```
+@inlinable @inline(__always)
+public static func size<
+    T: TensorFlowScalar,
+    OutType: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>
+) -> Tensor<OutType> {
+  let nOutputs = Int(1)
+    let op = makeOp("Size", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that skips `count` elements from the `input_dataset`.
+///
+/// - Parameter count: A scalar representing the number of elements from the `input_dataset`
+///     that should be skipped.  If count is -1, skips everything.
+@inlinable @inline(__always)
+public static func skipDataset(
+    inputDataset: VariantHandle,
+    count: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("SkipDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(count)
+    return op.execute(Int(1))
+}
+
+/// Parses a text file and creates a batch of examples.
+///
+/// - Attrs:
+///     - filename: The corpus's text file name.
+///     - batch_size: The size of produced batch.
+///     - window_size: The number of words to predict to the left and right of the target.
+///     - min_count: The minimum number of word occurrences for it to be included in the
+///         vocabulary.
+///     - subsample: Threshold for word occurrence. Words that appear with higher
+///         frequency will be randomly down-sampled. Set to 0 to disable.
+///
+/// - Outputs:
+///     - vocab_word: A vector of words in the corpus.
+///     - vocab_freq: Frequencies of words. Sorted in the non-ascending order.
+///     - words_per_epoch: Number of words per epoch in the data file.
+///     - current_epoch: The current epoch number.
+///     - total_words_processed: The total number of words processed so far.
+///     - examples: A vector of word ids.
+///     - labels: A vector of word ids.
+@inlinable @inline(__always)
+public static func skipgram(
+    filename: String,
+    batchSize: Int64,
+    windowSize: Int64 = 5,
+    minCount: Int64 = 5,
+    subsample: Double = 0.001
+) -> (vocabWord: StringTensor, vocabFreq: Tensor<Int32>, wordsPerEpoch: Tensor<Int64>, currentEpoch: Tensor<Int32>, totalWordsProcessed: Tensor<Int64>, examples: Tensor<Int32>, labels: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("Skipgram", nOutputs)
+    op.updateAttribute("filename", filename)
+    op.updateAttribute("batch_size", batchSize)
+    op.updateAttribute("window_size", windowSize)
+    op.updateAttribute("min_count", minCount)
+    op.updateAttribute("subsample", subsample)
+    return op.execute(Int(1), Int(1), Int(1), Int(1), Int(1), Int(1), Int(1))
+}
+
+/// Return a slice from 'input'.
+///
+/// The output tensor is a tensor with dimensions described by 'size'
+/// whose values are extracted from 'input' starting at the offsets in
+/// 'begin'.
+///
+/// *Requirements*:
+///   0 <= begin[i] <= begin[i] + size[i] <= Di  for i in [0, n)
+///
+/// - Parameters:
+///     - begin: begin[i] specifies the offset into the 'i'th dimension of
+///         'input' to slice from.
+///     - size: size[i] specifies the number of elements of the 'i'th dimension
+///         of 'input' to slice. If size[i] is -1, all remaining elements in dimension
+///         i are included in the slice (i.e. this is equivalent to setting
+///         size[i] = input.dim_size(i) - begin[i]).
+@inlinable @inline(__always)
+public static func slice<
+    T: TensorFlowScalar,
+    Index: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    begin: Tensor<Index>,
+    size: Tensor<Index>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Slice", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Index", Index.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(begin)
+    op.addInput(size)
+    return op.execute(Int(1))
+}
+
+/// Returns a copy of the input tensor.
+@inlinable @inline(__always)
+public static func snapshot<T: TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Snapshot", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Computes softmax activations.
+///
+/// For each batch `i` and class `j` we have
+///
+///     $$softmax[i, j] = exp(logits[i, j]) / sum_j(exp(logits[i, j]))$$
+///
+/// - Parameter logits: 2-D with shape `[batch_size, num_classes]`.
+///
+/// - Output softmax: Same shape as `logits`.
+@inlinable @inline(__always)
+public static func softmax<T: FloatingPoint & TensorFlowScalar>(
+    logits: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Softmax", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(logits)
+    return op.execute(Int(1))
+}
+
+/// Computes softmax cross entropy cost and gradients to backpropagate.
+///
+/// Inputs are the logits, not probabilities.
+///
+/// - Parameters:
+///     - features: batch_size x num_classes matrix
+///     - labels: batch_size x num_classes matrix
+///         The caller must ensure that each batch of labels represents a valid
+///         probability distribution.
+///
+/// - Outputs:
+///     - loss: Per example loss (batch_size vector).
+///     - backprop: backpropagated gradients (batch_size x num_classes matrix).
+@inlinable @inline(__always)
+public static func softmaxCrossEntropyWithLogits<T: FloatingPoint & TensorFlowScalar>(
+    features: Tensor<T>,
+    labels: Tensor<T>
+) -> (loss: Tensor<T>, backprop: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("SoftmaxCrossEntropyWithLogits", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(features)
+    op.addInput(labels)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Computes softplus: `log(exp(features) + 1)`.
+@inlinable @inline(__always)
+public static func softplus<T: FloatingPoint & TensorFlowScalar>(
+    features: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Softplus", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(features)
+    return op.execute(Int(1))
+}
+
+/// Computes softplus gradients for a softplus operation.
+///
+/// - Parameters:
+///     - gradients: The backpropagated gradients to the corresponding softplus operation.
+///     - features: The features passed as input to the corresponding softplus operation.
+///
+/// - Output backprops: The gradients: `gradients / (1 + exp(-features))`.
+@inlinable @inline(__always)
+public static func softplusGrad<T: FloatingPoint & TensorFlowScalar>(
+    gradients: Tensor<T>,
+    features: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SoftplusGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(gradients)
+    op.addInput(features)
+    return op.execute(Int(1))
+}
+
+/// Computes softsign: `features / (abs(features) + 1)`.
+@inlinable @inline(__always)
+public static func softsign<T: FloatingPoint & TensorFlowScalar>(
+    features: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Softsign", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(features)
+    return op.execute(Int(1))
+}
+
+/// Computes softsign gradients for a softsign operation.
+///
+/// - Parameters:
+///     - gradients: The backpropagated gradients to the corresponding softsign operation.
+///     - features: The features passed as input to the corresponding softsign operation.
+///
+/// - Output backprops: The gradients: `gradients / (1 + abs(features)) ** 2`.
+@inlinable @inline(__always)
+public static func softsignGrad<T: FloatingPoint & TensorFlowScalar>(
+    gradients: Tensor<T>,
+    features: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SoftsignGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(gradients)
+    op.addInput(features)
+    return op.execute(Int(1))
+}
+
+/// SpaceToBatch for 4-D tensors of type T.
+///
+/// This is a legacy version of the more general SpaceToBatchND.
+///
+/// Zero-pads and then rearranges (permutes) blocks of spatial data into batch.
+/// More specifically, this op outputs a copy of the input tensor where values from
+/// the `height` and `width` dimensions are moved to the `batch` dimension. After
+/// the zero-padding, both `height` and `width` of the input must be divisible by the
+/// block size.
+///
+/// - Parameters:
+///     - input: 4-D with shape `[batch, height, width, depth]`.
+///     - paddings: 2-D tensor of non-negative integers with shape `[2, 2]`. It specifies
+///           the padding of the input with zeros across the spatial dimensions as follows:
+///
+///               paddings = [[pad_top, pad_bottom], [pad_left, pad_right]]
+///
+///           The effective spatial dimensions of the zero-padded input tensor will be:
+///
+///               height_pad = pad_top + height + pad_bottom
+///               width_pad = pad_left + width + pad_right
+///
+///         The attr `block_size` must be greater than one. It indicates the block size.
+///
+///           * Non-overlapping blocks of size `block_size x block size` in the height and
+///             width dimensions are rearranged into the batch dimension at each location.
+///           * The batch of the output tensor is `batch * block_size * block_size`.
+///           * Both height_pad and width_pad must be divisible by block_size.
+///
+///         The shape of the output will be:
+///
+///             [batch*block_size*block_size, height_pad/block_size, width_pad/block_size,
+///              depth]
+///
+///         Some examples:
+///
+///         (1) For the following input of shape `[1, 2, 2, 1]` and block_size of 2:
+///
+///         ```
+///         x = [[[[1], [2]], [[3], [4]]]]
+///         ```
+///
+///         The output tensor has shape `[4, 1, 1, 1]` and value:
+///
+///         ```
+///         [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+///         ```
+///
+///         (2) For the following input of shape `[1, 2, 2, 3]` and block_size of 2:
+///
+///         ```
+///         x = [[[[1, 2, 3], [4, 5, 6]],
+///               [[7, 8, 9], [10, 11, 12]]]]
+///         ```
+///
+///         The output tensor has shape `[4, 1, 1, 3]` and value:
+///
+///         ```
+///         [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
+///         ```
+///
+///         (3) For the following input of shape `[1, 4, 4, 1]` and block_size of 2:
+///
+///         ```
+///         x = [[[[1],   [2],  [3],  [4]],
+///               [[5],   [6],  [7],  [8]],
+///               [[9],  [10], [11],  [12]],
+///               [[13], [14], [15],  [16]]]]
+///         ```
+///
+///         The output tensor has shape `[4, 2, 2, 1]` and value:
+///
+///         ```
+///         x = [[[[1], [3]], [[9], [11]]],
+///              [[[2], [4]], [[10], [12]]],
+///              [[[5], [7]], [[13], [15]]],
+///              [[[6], [8]], [[14], [16]]]]
+///         ```
+///
+///         (4) For the following input of shape `[2, 2, 4, 1]` and block_size of 2:
+///
+///         ```
+///         x = [[[[1],   [2],  [3],  [4]],
+///               [[5],   [6],  [7],  [8]]],
+///              [[[9],  [10], [11],  [12]],
+///               [[13], [14], [15],  [16]]]]
+///         ```
+///
+///         The output tensor has shape `[8, 1, 2, 1]` and value:
+///
+///         ```
+///         x = [[[[1], [3]]], [[[9], [11]]], [[[2], [4]]], [[[10], [12]]],
+///              [[[5], [7]]], [[[13], [15]]], [[[6], [8]]], [[[14], [16]]]]
+///         ```
+///
+///         Among others, this operation is useful for reducing atrous convolution into
+///         regular convolution.
+@inlinable @inline(__always)
+public static func spaceToBatch<
+    T: TensorFlowScalar,
+    Tpaddings: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    paddings: Tensor<Tpaddings>,
+    blockSize: Int64
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SpaceToBatch", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tpaddings", Tpaddings.tensorFlowDataType)
+    op.updateAttribute("block_size", blockSize)
+    op.addInput(input)
+    op.addInput(paddings)
+    return op.execute(Int(1))
+}
+
+/// SpaceToBatch for N-D tensors of type T.
+///
+/// This operation divides "spatial" dimensions `[1, ..., M]` of the input into a
+/// grid of blocks of shape `block_shape`, and interleaves these blocks with the
+/// "batch" dimension (0) such that in the output, the spatial dimensions
+/// `[1, ..., M]` correspond to the position within the grid, and the batch
+/// dimension combines both the position within a spatial block and the original
+/// batch position.  Prior to division into blocks, the spatial dimensions of the
+/// input are optionally zero padded according to `paddings`.  See below for a
+/// precise description.
+///
+/// - Parameters:
+///     - input: N-D with shape `input_shape = [batch] + spatial_shape + remaining_shape`,
+///         where spatial_shape has `M` dimensions.
+///     - block_shape: 1-D with shape `[M]`, all values must be >= 1.
+///     - paddings: 2-D with shape `[M, 2]`, all values must be >= 0.
+///           `paddings[i] = [pad_start, pad_end]` specifies the padding for input dimension
+///           `i + 1`, which corresponds to spatial dimension `i`.  It is required that
+///           `block_shape[i]` divides `input_shape[i + 1] + pad_start + pad_end`.
+///
+///         This operation is equivalent to the following steps:
+///
+///         1. Zero-pad the start and end of dimensions `[1, ..., M]` of the
+///            input according to `paddings` to produce `padded` of shape `padded_shape`.
+///
+///         2. Reshape `padded` to `reshaped_padded` of shape:
+///
+///              [batch] +
+///              [padded_shape[1] / block_shape[0],
+///                block_shape[0],
+///               ...,
+///               padded_shape[M] / block_shape[M-1],
+///               block_shape[M-1]] +
+///              remaining_shape
+///
+///         3. Permute dimensions of `reshaped_padded` to produce
+///            `permuted_reshaped_padded` of shape:
+///
+///              block_shape +
+///              [batch] +
+///              [padded_shape[1] / block_shape[0],
+///               ...,
+///               padded_shape[M] / block_shape[M-1]] +
+///              remaining_shape
+///
+///         4. Reshape `permuted_reshaped_padded` to flatten `block_shape` into the batch
+///            dimension, producing an output tensor of shape:
+///
+///              [batch * prod(block_shape)] +
+///              [padded_shape[1] / block_shape[0],
+///               ...,
+///               padded_shape[M] / block_shape[M-1]] +
+///              remaining_shape
+///
+///         Some examples:
+///
+///         (1) For the following input of shape `[1, 2, 2, 1]`, `block_shape = [2, 2]`, and
+///             `paddings = [[0, 0], [0, 0]]`:
+///
+///         ```
+///         x = [[[[1], [2]], [[3], [4]]]]
+///         ```
+///
+///         The output tensor has shape `[4, 1, 1, 1]` and value:
+///
+///         ```
+///         [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
+///         ```
+///
+///         (2) For the following input of shape `[1, 2, 2, 3]`, `block_shape = [2, 2]`, and
+///             `paddings = [[0, 0], [0, 0]]`:
+///
+///         ```
+///         x = [[[[1, 2, 3], [4, 5, 6]],
+///               [[7, 8, 9], [10, 11, 12]]]]
+///         ```
+///
+///         The output tensor has shape `[4, 1, 1, 3]` and value:
+///
+///         ```
+///         [[[[1, 2, 3]]], [[[4, 5, 6]]], [[[7, 8, 9]]], [[[10, 11, 12]]]]
+///         ```
+///
+///         (3) For the following input of shape `[1, 4, 4, 1]`, `block_shape = [2, 2]`, and
+///             `paddings = [[0, 0], [0, 0]]`:
+///
+///         ```
+///         x = [[[[1],   [2],  [3],  [4]],
+///               [[5],   [6],  [7],  [8]],
+///               [[9],  [10], [11],  [12]],
+///               [[13], [14], [15],  [16]]]]
+///         ```
+///
+///         The output tensor has shape `[4, 2, 2, 1]` and value:
+///
+///         ```
+///         x = [[[[1], [3]], [[9], [11]]],
+///              [[[2], [4]], [[10], [12]]],
+///              [[[5], [7]], [[13], [15]]],
+///              [[[6], [8]], [[14], [16]]]]
+///         ```
+///
+///         (4) For the following input of shape `[2, 2, 4, 1]`, block_shape = `[2, 2]`, and
+///             paddings = `[[0, 0], [2, 0]]`:
+///
+///         ```
+///         x = [[[[1],   [2],  [3],  [4]],
+///               [[5],   [6],  [7],  [8]]],
+///              [[[9],  [10], [11],  [12]],
+///               [[13], [14], [15],  [16]]]]
+///         ```
+///
+///         The output tensor has shape `[8, 1, 3, 1]` and value:
+///
+///         ```
+///         x = [[[[0], [1], [3]]], [[[0], [9], [11]]],
+///              [[[0], [2], [4]]], [[[0], [10], [12]]],
+///              [[[0], [5], [7]]], [[[0], [13], [15]]],
+///              [[[0], [6], [8]]], [[[0], [14], [16]]]]
+///         ```
+///
+///         Among others, this operation is useful for reducing atrous convolution into
+///         regular convolution.
+@inlinable @inline(__always)
+public static func spaceToBatchND<
+    T: TensorFlowScalar,
+    TblockShape: BinaryInteger & TensorFlowScalar,
+    Tpaddings: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    blockShape: Tensor<TblockShape>,
+    paddings: Tensor<Tpaddings>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SpaceToBatchND", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tblock_shape", TblockShape.tensorFlowDataType)
+    op.updateAttribute("Tpaddings", Tpaddings.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(blockShape)
+    op.addInput(paddings)
+    return op.execute(Int(1))
+}
+
+/// SpaceToDepth for tensors of type T.
+///
+/// Rearranges blocks of spatial data, into depth. More specifically,
+/// this op outputs a copy of the input tensor where values from the `height`
+/// and `width` dimensions are moved to the `depth` dimension.
+/// The attr `block_size` indicates the input block size.
+///
+///   * Non-overlapping blocks of size `block_size x block size` are rearranged
+///     into depth at each location.
+///   * The depth of the output tensor is `block_size * block_size * input_depth`.
+///   * The Y, X coordinates within each block of the input become the high order
+///     component of the output channel index.
+///   * The input tensor's height and width must be divisible by block_size.
+///
+/// The `data_format` attr specifies the layout of the input and output tensors
+/// with the following options:
+///   "NHWC": `[ batch, height, width, channels ]`
+///   "NCHW": `[ batch, channels, height, width ]`
+///   "NCHW_VECT_C":
+///       `qint8 [ batch, channels / 4, height, width, 4 ]`
+///
+/// It is useful to consider the operation as transforming a 6-D Tensor.
+/// e.g. for data_format = NHWC,
+///      Each element in the input tensor can be specified via 6 coordinates,
+///      ordered by decreasing memory layout significance as:
+///      n,oY,bY,oX,bX,iC  (where n=batch index, oX, oY means X or Y coordinates
+///                         within the output image, bX, bY means coordinates
+///                         within the input block, iC means input channels).
+///      The output would be a transpose to the following layout:
+///      n,oY,oX,bY,bX,iC
+///
+/// This operation is useful for resizing the activations between convolutions
+/// (but keeping all data), e.g. instead of pooling. It is also useful for training
+/// purely convolutional models.
+///
+/// For example, given an input of shape `[1, 2, 2, 1]`, data_format = "NHWC" and
+/// block_size = 2:
+///
+/// ```
+/// x = [[[[1], [2]],
+///       [[3], [4]]]]
+/// ```
+///
+/// This operation will output a tensor of shape `[1, 1, 1, 4]`:
+///
+/// ```
+/// [[[[1, 2, 3, 4]]]]
+/// ```
+///
+/// Here, the input has a batch of 1 and each batch element has shape `[2, 2, 1]`,
+/// the corresponding output will have a single element (i.e. width and height are
+/// both 1) and will have a depth of 4 channels (1 * block_size * block_size).
+/// The output element shape is `[1, 1, 4]`.
+///
+/// For an input tensor with larger depth, here of shape `[1, 2, 2, 3]`, e.g.
+///
+/// ```
+/// x = [[[[1, 2, 3], [4, 5, 6]],
+///       [[7, 8, 9], [10, 11, 12]]]]
+/// ```
+///
+/// This operation, for block_size of 2, will return the following tensor of shape
+/// `[1, 1, 1, 12]`
+///
+/// ```
+/// [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
+/// ```
+///
+/// Similarly, for the following input of shape `[1 4 4 1]`, and a block size of 2:
+///
+/// ```
+/// x = [[[[1],   [2],  [5],  [6]],
+///       [[3],   [4],  [7],  [8]],
+///       [[9],  [10], [13],  [14]],
+///       [[11], [12], [15],  [16]]]]
+/// ```
+///
+/// the operator will return the following tensor of shape `[1 2 2 4]`:
+///
+/// ```
+/// x = [[[[1, 2, 3, 4],
+///        [5, 6, 7, 8]],
+///       [[9, 10, 11, 12],
+///        [13, 14, 15, 16]]]]
+/// ```
+///
+/// - Attr block_size: The size of the spatial block.
+@inlinable @inline(__always)
+public static func spaceToDepth<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    blockSize: Int64,
+    dataFormat: DataFormat4 = .nhwc
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SpaceToDepth", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("block_size", blockSize)
+    op.updateAttribute("data_format", dataFormat.cName)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Adds two `SparseTensor` objects to produce another `SparseTensor`.
+///
+/// The input `SparseTensor` objects' indices are assumed ordered in standard
+/// lexicographic order.  If this is not the case, before this step run
+/// `SparseReorder` to restore index ordering.
+///
+/// By default, if two values sum to zero at some index, the output `SparseTensor`
+/// would still include that particular location in its index, storing a zero in the
+/// corresponding value slot.  To override this, callers can specify `thresh`,
+/// indicating that if the sum has a magnitude strictly smaller than `thresh`, its
+/// corresponding value and index would then not be included.  In particular,
+/// `thresh == 0` (default) means everything is kept and actual thresholding happens
+/// only for a positive value.
+///
+/// In the following shapes, `nnz` is the count after taking `thresh` into account.
+///
+/// - Parameters:
+///     - a_indices: 2-D.  The `indices` of the first `SparseTensor`, size `[nnz, ndims]` Matrix.
+///     - a_values: 1-D.  The `values` of the first `SparseTensor`, size `[nnz]` Vector.
+///     - a_shape: 1-D.  The `shape` of the first `SparseTensor`, size `[ndims]` Vector.
+///     - b_indices: 2-D.  The `indices` of the second `SparseTensor`, size `[nnz, ndims]` Matrix.
+///     - b_values: 1-D.  The `values` of the second `SparseTensor`, size `[nnz]` Vector.
+///     - b_shape: 1-D.  The `shape` of the second `SparseTensor`, size `[ndims]` Vector.
+///     - thresh: 0-D.  The magnitude threshold that determines if an output value/index
+///         pair takes space.
+@inlinable @inline(__always)
+public static func sparseAdd<
+    T: Numeric & TensorFlowScalar,
+    Treal: Numeric & TensorFlowScalar
+>(
+    aIndices: Tensor<Int64>,
+    aValues: Tensor<T>,
+    aShape: Tensor<Int64>,
+    bIndices: Tensor<Int64>,
+    bValues: Tensor<T>,
+    bShape: Tensor<Int64>,
+    thresh: Tensor<Treal>
+) -> (sumIndices: Tensor<Int64>, sumValues: Tensor<T>, sumShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("SparseAdd", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Treal", Treal.tensorFlowDataType)
+    op.addInput(aIndices)
+    op.addInput(aValues)
+    op.addInput(aShape)
+    op.addInput(bIndices)
+    op.addInput(bValues)
+    op.addInput(bShape)
+    op.addInput(thresh)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// The gradient operator for the SparseAdd op.
+///
+/// The SparseAdd op calculates A + B, where A, B, and the sum are all represented
+/// as `SparseTensor` objects.  This op takes in the upstream gradient w.r.t.
+/// non-empty values of the sum, and outputs the gradients w.r.t. the non-empty
+/// values of A and B.
+///
+/// - Parameters:
+///     - backprop_val_grad: 1-D with shape `[nnz(sum)]`.  The gradient with respect to
+///         the non-empty values of the sum.
+///     - a_indices: 2-D.  The `indices` of the `SparseTensor` A, size `[nnz(A), ndims]`.
+///     - b_indices: 2-D.  The `indices` of the `SparseTensor` B, size `[nnz(B), ndims]`.
+///     - sum_indices: 2-D.  The `indices` of the sum `SparseTensor`, size
+///         `[nnz(sum), ndims]`.
+///
+/// - Outputs:
+///     - a_val_grad: 1-D with shape `[nnz(A)]`. The gradient with respect to the
+///         non-empty values of A.
+///     - b_val_grad: 1-D with shape `[nnz(B)]`. The gradient with respect to the
+///         non-empty values of B.
+@inlinable @inline(__always)
+public static func sparseAddGrad<T: Numeric & TensorFlowScalar>(
+    backpropValGrad: Tensor<T>,
+    aIndices: Tensor<Int64>,
+    bIndices: Tensor<Int64>,
+    sumIndices: Tensor<Int64>
+) -> (aValGrad: Tensor<T>, bValGrad: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("SparseAddGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(backpropValGrad)
+    op.addInput(aIndices)
+    op.addInput(bIndices)
+    op.addInput(sumIndices)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Concatenates a list of `SparseTensor` along the specified dimension.
+///
+/// Concatenation is with respect to the dense versions of these sparse tensors.
+/// It is assumed that each input is a `SparseTensor` whose elements are ordered
+/// along increasing dimension number.
+///
+/// All inputs' shapes must match, except for the concat dimension.  The
+/// `indices`, `values`, and `shapes` lists must have the same length.
+///
+/// The output shape is identical to the inputs', except along the concat
+/// dimension, where it is the sum of the inputs' sizes along that dimension.
+///
+/// The output elements will be resorted to preserve the sort order along
+/// increasing dimension number.
+///
+/// This op runs in `O(M log M)` time, where `M` is the total number of non-empty
+/// values across all inputs. This is due to the need for an internal sort in
+/// order to concatenate efficiently across an arbitrary dimension.
+///
+/// For example, if `concat_dim = 1` and the inputs are
+///
+///     sp_inputs[0]: shape = [2, 3]
+///     [0, 2]: "a"
+///     [1, 0]: "b"
+///     [1, 1]: "c"
+///
+///     sp_inputs[1]: shape = [2, 4]
+///     [0, 1]: "d"
+///     [0, 2]: "e"
+///
+/// then the output will be
+///
+///     shape = [2, 7]
+///     [0, 2]: "a"
+///     [0, 4]: "d"
+///     [0, 5]: "e"
+///     [1, 0]: "b"
+///     [1, 1]: "c"
+///
+/// Graphically this is equivalent to doing
+///
+///     [    a] concat [  d e  ] = [    a   d e  ]
+///     [b c  ]        [       ]   [b c          ]
+///
+/// - Parameters:
+///     - indices: 2-D.  Indices of each input `SparseTensor`.
+///     - values: 1-D.  Non-empty values of each `SparseTensor`.
+///     - shapes: 1-D.  Shapes of each `SparseTensor`.
+///
+/// - Attr concat_dim: Dimension to concatenate along. Must be in range [-rank, rank),
+///     where rank is the number of dimensions in each input `SparseTensor`.
+///
+/// - Outputs:
+///     - output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
+///     - output_values: 1-D.  Non-empty values of the concatenated `SparseTensor`.
+///     - output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
+@inlinable @inline(__always)
+public static func sparseConcat<T: TensorFlowScalar>(
+    indices: [Tensor<Int64>],
+    _ values: [Tensor<T>],
+    shapes: [Tensor<Int64>],
+    concatDim: Int64
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, outputShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("SparseConcat", nOutputs)
+    op.updateAttribute("concat_dim", concatDim)
+    op.updateAttribute("N", indices.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInputList(indices)
+    op.addInputList(values)
+    op.addInputList(shapes)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Generates sparse cross from a list of sparse and dense tensors.
+///
+/// The op takes two lists, one of 2D `SparseTensor` and one of 2D `Tensor`, each
+/// representing features of one feature column. It outputs a 2D `SparseTensor` with
+/// the batchwise crosses of these features.
+///
+/// For example, if the inputs are
+///
+///     inputs[0]: SparseTensor with shape = [2, 2]
+///     [0, 0]: "a"
+///     [1, 0]: "b"
+///     [1, 1]: "c"
+///
+///     inputs[1]: SparseTensor with shape = [2, 1]
+///     [0, 0]: "d"
+///     [1, 0]: "e"
+///
+///     inputs[2]: Tensor [["f"], ["g"]]
+///
+/// then the output will be
+///
+///     shape = [2, 2]
+///     [0, 0]: "a_X_d_X_f"
+///     [1, 0]: "b_X_e_X_g"
+///     [1, 1]: "c_X_e_X_g"
+///
+/// if hashed_output=true then the output will be
+///
+///     shape = [2, 2]
+///     [0, 0]: FingerprintCat64(
+///                 Fingerprint64("f"), FingerprintCat64(
+///                     Fingerprint64("d"), Fingerprint64("a")))
+///     [1, 0]: FingerprintCat64(
+///                 Fingerprint64("g"), FingerprintCat64(
+///                     Fingerprint64("e"), Fingerprint64("b")))
+///     [1, 1]: FingerprintCat64(
+///                 Fingerprint64("g"), FingerprintCat64(
+///                     Fingerprint64("e"), Fingerprint64("c")))
+///
+/// - Parameters:
+///     - indices: 2-D.  Indices of each input `SparseTensor`.
+///     - values: 1-D.   values of each `SparseTensor`.
+///     - shapes: 1-D.   Shapes of each `SparseTensor`.
+///     - dense_inputs: 2-D.    Columns represented by dense `Tensor`.
+///
+/// - Attrs:
+///     - hashed_output: If true, returns the hash of the cross instead of the string.
+///         This will allow us avoiding string manipulations.
+///     - num_buckets: It is used if hashed_output is true.
+///         output = hashed_value%num_buckets if num_buckets > 0 else hashed_value.
+///     - hash_key: Specify the hash_key that will be used by the `FingerprintCat64`
+///         function to combine the crosses fingerprints.
+///
+/// - Outputs:
+///     - output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
+///     - output_values: 1-D.  Non-empty values of the concatenated or hashed
+///         `SparseTensor`.
+///     - output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
+@inlinable @inline(__always)
+public static func sparseCross<
+    SparseTypes: TensorArrayProtocol,
+    DenseTypes: TensorArrayProtocol,
+    OutType: BinaryInteger & TensorFlowScalar
+>(
+    indices: [Tensor<Int64>],
+    _ values: SparseTypes,
+    shapes: [Tensor<Int64>],
+    denseInputs: DenseTypes,
+    hashedOutput: Bool,
+    numBuckets: Int64,
+    hashKey: Int64,
+    internalType: TensorDataType
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<OutType>, outputShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("SparseCross", nOutputs)
+    op.updateAttribute("N", indices.count)
+    op.updateAttribute("hashed_output", hashedOutput)
+    op.updateAttribute("num_buckets", numBuckets)
+    op.updateAttribute("hash_key", hashKey)
+    op.updateAttribute("sparse_types", values._typeList)
+    op.updateAttribute("dense_types", denseInputs._typeList)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.updateAttribute("internal_type", internalType)
+    op.addInputList(indices)
+    op.addInputList(values)
+    op.addInputList(shapes)
+    op.addInputList(denseInputs)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Generates sparse cross from a list of sparse and dense tensors.
+///
+/// The op takes two lists, one of 2D `SparseTensor` and one of 2D `Tensor`, each
+/// representing features of one feature column. It outputs a 2D `SparseTensor` with
+/// the batchwise crosses of these features.
+///
+/// For example, if the inputs are
+///
+///     inputs[0]: SparseTensor with shape = [2, 2]
+///     [0, 0]: "a"
+///     [1, 0]: "b"
+///     [1, 1]: "c"
+///
+///     inputs[1]: SparseTensor with shape = [2, 1]
+///     [0, 0]: "d"
+///     [1, 0]: "e"
+///
+///     inputs[2]: Tensor [["f"], ["g"]]
+///
+/// then the output will be
+///
+///     shape = [2, 2]
+///     [0, 0]: "a_X_d_X_f"
+///     [1, 0]: "b_X_e_X_g"
+///     [1, 1]: "c_X_e_X_g"
+///
+/// if hashed_output=true then the output will be
+///
+///     shape = [2, 2]
+///     [0, 0]: FingerprintCat64(
+///                 Fingerprint64("f"), FingerprintCat64(
+///                     Fingerprint64("d"), Fingerprint64("a")))
+///     [1, 0]: FingerprintCat64(
+///                 Fingerprint64("g"), FingerprintCat64(
+///                     Fingerprint64("e"), Fingerprint64("b")))
+///     [1, 1]: FingerprintCat64(
+///                 Fingerprint64("g"), FingerprintCat64(
+///                     Fingerprint64("e"), Fingerprint64("c")))
+///
+/// - Parameters:
+///     - indices: 2-D.  Indices of each input `SparseTensor`.
+///     - values: 1-D.   values of each `SparseTensor`.
+///     - shapes: 1-D.   Shapes of each `SparseTensor`.
+///     - dense_inputs: 2-D.    Columns represented by dense `Tensor`.
+///
+/// - Attrs:
+///     - hashed_output: If true, returns the hash of the cross instead of the string.
+///         This will allow us avoiding string manipulations.
+///     - num_buckets: It is used if hashed_output is true.
+///         output = hashed_value%num_buckets if num_buckets > 0 else hashed_value.
+///     - hash_key: Specify the hash_key that will be used by the `FingerprintCat64`
+///         function to combine the crosses fingerprints.
+///
+/// - Outputs:
+///     - output_indices: 2-D.  Indices of the concatenated `SparseTensor`.
+///     - output_values: 1-D.  Non-empty values of the concatenated or hashed
+///         `SparseTensor`.
+///     - output_shape: 1-D.  Shape of the concatenated `SparseTensor`.
+@inlinable @inline(__always)
+public static func sparseCross<
+    SparseTypes: TensorArrayProtocol,
+    DenseTypes: TensorArrayProtocol
+>(
+    indices: [Tensor<Int64>],
+    _ values: SparseTypes,
+    shapes: [Tensor<Int64>],
+    denseInputs: DenseTypes,
+    hashedOutput: Bool,
+    numBuckets: Int64,
+    hashKey: Int64,
+    internalType: TensorDataType
+) -> (outputIndices: Tensor<Int64>, outputValues: StringTensor, outputShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("SparseCross", nOutputs)
+    op.updateAttribute("N", indices.count)
+    op.updateAttribute("hashed_output", hashedOutput)
+    op.updateAttribute("num_buckets", numBuckets)
+    op.updateAttribute("hash_key", hashKey)
+    op.updateAttribute("sparse_types", values._typeList)
+    op.updateAttribute("dense_types", denseInputs._typeList)
+    op.updateAttribute("out_type", TensorDataType(TF_STRING))
+    op.updateAttribute("internal_type", internalType)
+    op.addInputList(indices)
+    op.addInputList(values)
+    op.addInputList(shapes)
+    op.addInputList(denseInputs)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Adds up a SparseTensor and a dense Tensor, using these special rules:
+///
+/// (1) Broadcasts the dense side to have the same shape as the sparse side, if
+///     eligible;
+/// (2) Then, only the dense values pointed to by the indices of the SparseTensor
+///     participate in the cwise addition.
+///
+/// By these rules, the result is a logical SparseTensor with exactly the same
+/// indices and shape, but possibly with different non-zero values.  The output of
+/// this Op is the resultant non-zero values.
+///
+/// - Parameters:
+///     - sp_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///         SparseTensor, possibly not in canonical ordering.
+///     - sp_values: 1-D.  `N` non-empty values corresponding to `sp_indices`.
+///     - sp_shape: 1-D.  Shape of the input SparseTensor.
+///     - dense: `R`-D.  The dense Tensor operand.
+///
+/// - Output output: 1-D.  The `N` values that are operated on.
+@inlinable @inline(__always)
+public static func sparseDenseCwiseAdd<T: Numeric & TensorFlowScalar>(
+    spIndices: Tensor<Int64>,
+    spValues: Tensor<T>,
+    spShape: Tensor<Int64>,
+    dense: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseDenseCwiseAdd", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(spIndices)
+    op.addInput(spValues)
+    op.addInput(spShape)
+    op.addInput(dense)
+    return op.execute(Int(1))
+}
+
+/// Component-wise divides a SparseTensor by a dense Tensor.
+///
+/// *Limitation*: this Op only broadcasts the dense side to the sparse side, but not
+/// the other direction.
+///
+/// - Parameters:
+///     - sp_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///         SparseTensor, possibly not in canonical ordering.
+///     - sp_values: 1-D.  `N` non-empty values corresponding to `sp_indices`.
+///     - sp_shape: 1-D.  Shape of the input SparseTensor.
+///     - dense: `R`-D.  The dense Tensor operand.
+///
+/// - Output output: 1-D.  The `N` values that are operated on.
+@inlinable @inline(__always)
+public static func sparseDenseCwiseDiv<T: Numeric & TensorFlowScalar>(
+    spIndices: Tensor<Int64>,
+    spValues: Tensor<T>,
+    spShape: Tensor<Int64>,
+    dense: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseDenseCwiseDiv", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(spIndices)
+    op.addInput(spValues)
+    op.addInput(spShape)
+    op.addInput(dense)
+    return op.execute(Int(1))
+}
+
+/// Component-wise multiplies a SparseTensor by a dense Tensor.
+///
+/// The output locations corresponding to the implicitly zero elements in the sparse
+/// tensor will be zero (i.e., will not take up storage space), regardless of the
+/// contents of the dense tensor (even if it's +/-INF and that INF*0 == NaN).
+///
+/// *Limitation*: this Op only broadcasts the dense side to the sparse side, but not
+/// the other direction.
+///
+/// - Parameters:
+///     - sp_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///         SparseTensor, possibly not in canonical ordering.
+///     - sp_values: 1-D.  `N` non-empty values corresponding to `sp_indices`.
+///     - sp_shape: 1-D.  Shape of the input SparseTensor.
+///     - dense: `R`-D.  The dense Tensor operand.
+///
+/// - Output output: 1-D.  The `N` values that are operated on.
+@inlinable @inline(__always)
+public static func sparseDenseCwiseMul<T: Numeric & TensorFlowScalar>(
+    spIndices: Tensor<Int64>,
+    spValues: Tensor<T>,
+    spShape: Tensor<Int64>,
+    dense: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseDenseCwiseMul", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(spIndices)
+    op.addInput(spValues)
+    op.addInput(spShape)
+    op.addInput(dense)
+    return op.execute(Int(1))
+}
+
+/// Fills empty rows in the input 2-D `SparseTensor` with a default value.
+///
+/// The input `SparseTensor` is represented via the tuple of inputs
+/// (`indices`, `values`, `dense_shape`).  The output `SparseTensor` has the
+/// same `dense_shape` but with indices `output_indices` and values
+/// `output_values`.
+///
+/// This op inserts a single entry for every row that doesn't have any values.
+/// The index is created as `[row, 0, ..., 0]` and the inserted value
+/// is `default_value`.
+///
+/// For example, suppose `sp_input` has shape `[5, 6]` and non-empty values:
+///
+///     [0, 1]: a
+///     [0, 3]: b
+///     [2, 0]: c
+///     [3, 1]: d
+///
+/// Rows 1 and 4 are empty, so the output will be of shape `[5, 6]` with values:
+///
+///     [0, 1]: a
+///     [0, 3]: b
+///     [1, 0]: default_value
+///     [2, 0]: c
+///     [3, 1]: d
+///     [4, 0]: default_value
+///
+/// The output `SparseTensor` will be in row-major order and will have the
+/// same shape as the input.
+///
+/// This op also returns an indicator vector shaped `[dense_shape[0]]` such that
+///
+///     empty_row_indicator[i] = True iff row i was an empty row.
+///
+/// And a reverse index map vector shaped `[indices.shape[0]]` that is used during
+/// backpropagation,
+///
+///     reverse_index_map[j] = out_j s.t. indices[j, :] == output_indices[out_j, :]
+///
+/// - Parameters:
+///     - indices: 2-D. the indices of the sparse tensor.
+///     - values: 1-D. the values of the sparse tensor.
+///     - dense_shape: 1-D. the shape of the sparse tensor.
+///     - default_value: 0-D. default value to insert into location `[row, 0, ..., 0]`
+///           for rows missing from the input sparse tensor.
+///         output indices: 2-D. the indices of the filled sparse tensor.
+///
+/// - Outputs:
+///     - output_values: 1-D. the values of the filled sparse tensor.
+///     - empty_row_indicator: 1-D. whether the dense row was missing in the
+///         input sparse tensor.
+///     - reverse_index_map: 1-D. a map from the input indices to the output indices.
+@inlinable @inline(__always)
+public static func sparseFillEmptyRows<T: TensorFlowScalar>(
+    indices: Tensor<Int64>,
+    _ values: Tensor<T>,
+    denseShape: Tensor<Int64>,
+    defaultValue: Tensor<T>
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, emptyRowIndicator: Tensor<Bool>, reverseIndexMap: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1) + Int(1)
+    let op = makeOp("SparseFillEmptyRows", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(indices)
+    op.addInput(values)
+    op.addInput(denseShape)
+    op.addInput(defaultValue)
+    return op.execute(Int(1), Int(1), Int(1), Int(1))
+}
+
+/// The gradient of SparseFillEmptyRows.
+///
+/// Takes vectors reverse_index_map, shaped `[N]`, and grad_values,
+/// shaped `[N_full]`, where `N_full >= N` and copies data into either
+/// `d_values` or `d_default_value`.  Here `d_values` is shaped `[N]` and
+/// `d_default_value` is a scalar.
+///
+///   d_values[j] = grad_values[reverse_index_map[j]]
+///   d_default_value = sum_{k : 0 .. N_full - 1} (
+///      grad_values[k] * 1{k not in reverse_index_map})
+///
+/// - Parameters:
+///     - reverse_index_map: 1-D.  The reverse index map from SparseFillEmptyRows.
+///     - grad_values: 1-D.  The gradients from backprop.
+///
+/// - Outputs:
+///     - d_values: 1-D.  The backprop into values.
+///     - d_default_value: 0-D.  The backprop into default_value.
+@inlinable @inline(__always)
+public static func sparseFillEmptyRowsGrad<T: TensorFlowScalar>(
+    reverseIndexMap: Tensor<Int64>,
+    gradValues: Tensor<T>
+) -> (dValues: Tensor<T>, dDefaultValue: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("SparseFillEmptyRowsGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(reverseIndexMap)
+    op.addInput(gradValues)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Multiply matrix "a" by matrix "b".
+///
+/// The inputs must be two-dimensional matrices and the inner dimension of "a" must
+/// match the outer dimension of "b". Both "a" and "b" must be `Tensor`s not
+/// `SparseTensor`s.  This op is optimized for the case where at least one of "a" or
+/// "b" is sparse, in the sense that they have a large proportion of zero values.
+/// The breakeven for using this versus a dense matrix multiply on one platform was
+/// 30% zero values in the sparse matrix.
+///
+/// The gradient computation of this operation will only take advantage of sparsity
+/// in the input gradient when that gradient comes from a Relu.
+@inlinable @inline(__always)
+public static func sparseMatMul<
+    Ta: FloatingPoint & TensorFlowScalar,
+    Tb: FloatingPoint & TensorFlowScalar
+>(
+    _ a: Tensor<Ta>,
+    _ b: Tensor<Tb>,
+    transposeA: Bool = false,
+    transposeB: Bool = false,
+    aIsSparse: Bool = false,
+    bIsSparse: Bool = false
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseMatMul", nOutputs)
+    op.updateAttribute("transpose_a", transposeA)
+    op.updateAttribute("transpose_b", transposeB)
+    op.updateAttribute("a_is_sparse", aIsSparse)
+    op.updateAttribute("b_is_sparse", bIsSparse)
+    op.updateAttribute("Ta", Ta.tensorFlowDataType)
+    op.updateAttribute("Tb", Tb.tensorFlowDataType)
+    op.addInput(a)
+    op.addInput(b)
+    return op.execute(Int(1))
+}
+
+/// Computes the max of elements across dimensions of a SparseTensor.
+///
+/// This Op takes a SparseTensor and is the sparse counterpart to
+/// `tf.reduce_max()`.  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
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
+/// with length 1.
+///
+/// If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
+/// with a single element is returned.  Additionally, the axes can be negative,
+/// which are interpreted according to the indexing rules in Python.
+///
+/// - Parameters:
+///     - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///         SparseTensor, possibly not in canonical ordering.
+///     - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
+///     - input_shape: 1-D.  Shape of the input SparseTensor.
+///     - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: `R-K`-D.  The reduced Tensor.
+@inlinable @inline(__always)
+public static func sparseReduceMax<T: Numeric & TensorFlowScalar>(
+    inputIndices: Tensor<Int64>,
+    inputValues: Tensor<T>,
+    inputShape: Tensor<Int64>,
+    reductionAxes: Tensor<Int32>,
+    keepDims: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseReduceMax", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(inputIndices)
+    op.addInput(inputValues)
+    op.addInput(inputShape)
+    op.addInput(reductionAxes)
+    return op.execute(Int(1))
+}
+
+/// Computes the max of elements across dimensions of a SparseTensor.
+///
+/// This Op takes a SparseTensor and is the sparse counterpart to
+/// `tf.reduce_max()`.  In contrast to SparseReduceMax, this Op returns a
+/// SparseTensor.
+///
+/// Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
+/// with length 1.
+///
+/// If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
+/// with a single element is returned.  Additionally, the axes can be negative,
+/// which are interpreted according to the indexing rules in Python.
+///
+/// - Parameters:
+///     - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///         SparseTensor, possibly not in canonical ordering.
+///     - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
+///     - input_shape: 1-D.  Shape of the input SparseTensor.
+///     - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+@inlinable @inline(__always)
+public static func sparseReduceMaxSparse<T: Numeric & TensorFlowScalar>(
+    inputIndices: Tensor<Int64>,
+    inputValues: Tensor<T>,
+    inputShape: Tensor<Int64>,
+    reductionAxes: Tensor<Int32>,
+    keepDims: Bool = false
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, outputShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("SparseReduceMaxSparse", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(inputIndices)
+    op.addInput(inputValues)
+    op.addInput(inputShape)
+    op.addInput(reductionAxes)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes the sum of elements across dimensions of a SparseTensor.
+///
+/// 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
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
+/// with length 1.
+///
+/// If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
+/// with a single element is returned.  Additionally, the axes can be negative,
+/// which are interpreted according to the indexing rules in Python.
+///
+/// - Parameters:
+///     - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///         SparseTensor, possibly not in canonical ordering.
+///     - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
+///     - input_shape: 1-D.  Shape of the input SparseTensor.
+///     - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: `R-K`-D.  The reduced Tensor.
+@inlinable @inline(__always)
+public static func sparseReduceSum<T: Numeric & TensorFlowScalar>(
+    inputIndices: Tensor<Int64>,
+    inputValues: Tensor<T>,
+    inputShape: Tensor<Int64>,
+    reductionAxes: Tensor<Int32>,
+    keepDims: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseReduceSum", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(inputIndices)
+    op.addInput(inputValues)
+    op.addInput(inputShape)
+    op.addInput(reductionAxes)
+    return op.execute(Int(1))
+}
+
+/// Computes the sum of elements across dimensions of a SparseTensor.
+///
+/// This Op takes a SparseTensor and is the sparse counterpart to
+/// `tf.reduce_sum()`.  In contrast to SparseReduceSum, this Op returns a
+/// SparseTensor.
+///
+/// Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `reduction_axes`. If `keep_dims` is true, the reduced dimensions are retained
+/// with length 1.
+///
+/// If `reduction_axes` has no entries, all dimensions are reduced, and a tensor
+/// with a single element is returned.  Additionally, the axes can be negative,
+/// which are interpreted according to the indexing rules in Python.
+///
+/// - Parameters:
+///     - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///         SparseTensor, possibly not in canonical ordering.
+///     - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
+///     - input_shape: 1-D.  Shape of the input SparseTensor.
+///     - reduction_axes: 1-D.  Length-`K` vector containing the reduction axes.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+@inlinable @inline(__always)
+public static func sparseReduceSumSparse<T: Numeric & TensorFlowScalar>(
+    inputIndices: Tensor<Int64>,
+    inputValues: Tensor<T>,
+    inputShape: Tensor<Int64>,
+    reductionAxes: Tensor<Int32>,
+    keepDims: Bool = false
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, outputShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("SparseReduceSumSparse", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(inputIndices)
+    op.addInput(inputValues)
+    op.addInput(inputShape)
+    op.addInput(reductionAxes)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Reorders a SparseTensor into the canonical, row-major ordering.
+///
+/// Note that by convention, all sparse ops preserve the canonical ordering along
+/// increasing dimension number. The only time ordering can be violated is during
+/// manual manipulation of the indices and values vectors to add entries.
+///
+/// Reordering does not affect the shape of the SparseTensor.
+///
+/// If the tensor has rank `R` and `N` non-empty values, `input_indices` has
+/// shape `[N, R]`, input_values has length `N`, and input_shape has length `R`.
+///
+/// - Parameters:
+///     - input_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+///         SparseTensor, possibly not in canonical ordering.
+///     - input_values: 1-D.  `N` non-empty values corresponding to `input_indices`.
+///     - input_shape: 1-D.  Shape of the input SparseTensor.
+///
+/// - Outputs:
+///     - output_indices: 2-D.  `N x R` matrix with the same indices as input_indices, but
+///         in canonical row-major ordering.
+///     - output_values: 1-D.  `N` non-empty values corresponding to `output_indices`.
+@inlinable @inline(__always)
+public static func sparseReorder<T: TensorFlowScalar>(
+    inputIndices: Tensor<Int64>,
+    inputValues: Tensor<T>,
+    inputShape: Tensor<Int64>
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("SparseReorder", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(inputIndices)
+    op.addInput(inputValues)
+    op.addInput(inputShape)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Reshapes a SparseTensor to represent values in a new dense shape.
+///
+/// This operation has the same semantics as reshape on the represented dense
+/// tensor.  The `input_indices` are recomputed based on the requested `new_shape`.
+///
+/// If one component of `new_shape` is the special value -1, the size of that
+/// dimension is computed so that the total dense size remains constant.  At
+/// most one component of `new_shape` can be -1.  The number of dense elements
+/// implied by `new_shape` must be the same as the number of dense elements
+/// originally implied by `input_shape`.
+///
+/// Reshaping does not affect the order of values in the SparseTensor.
+///
+/// If the input tensor has rank `R_in` and `N` non-empty values, and `new_shape`
+/// has length `R_out`, then `input_indices` has shape `[N, R_in]`,
+/// `input_shape` has length `R_in`, `output_indices` has shape `[N, R_out]`, and
+/// `output_shape` has length `R_out`.
+///
+/// - Parameters:
+///     - input_indices: 2-D.  `N x R_in` matrix with the indices of non-empty values in a
+///         SparseTensor.
+///     - input_shape: 1-D.  `R_in` vector with the input SparseTensor's dense shape.
+///     - new_shape: 1-D.  `R_out` vector with the requested new dense shape.
+///
+/// - Outputs:
+///     - output_indices: 2-D.  `N x R_out` matrix with the updated indices of non-empty
+///         values in the output SparseTensor.
+///     - output_shape: 1-D.  `R_out` vector with the full dense shape of the output
+///         SparseTensor.  This is the same as `new_shape` but with any -1 dimensions
+///         filled in.
+@inlinable @inline(__always)
+public static func sparseReshape(
+    inputIndices: Tensor<Int64>,
+    inputShape: Tensor<Int64>,
+    newShape: Tensor<Int64>
+) -> (outputIndices: Tensor<Int64>, outputShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("SparseReshape", nOutputs)
+    op.addInput(inputIndices)
+    op.addInput(inputShape)
+    op.addInput(newShape)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Computes the mean along sparse segments of a tensor.
+///
+/// See `tf.sparse.segment_sum` for usage examples.
+///
+/// Like `SegmentMean`, but `segment_ids` can have rank less than `data`'s first
+/// dimension, selecting a subset of dimension 0, specified by `indices`.
+///
+/// - Parameters:
+///     - indices: A 1-D tensor. Has same rank as `segment_ids`.
+///     - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///     has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func sparseSegmentMean<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    indices: Tensor<Tidx>,
+    segmentIds: Tensor<Int32>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseSegmentMean", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(indices)
+    op.addInput(segmentIds)
+    return op.execute(Int(1))
+}
+
+/// Computes gradients for SparseSegmentMean.
+///
+/// Returns tensor "output" with same shape as grad, except for dimension 0 whose
+/// value is output_dim0.
+///
+/// - Parameters:
+///     - grad: gradient propagated to the SparseSegmentMean op.
+///     - indices: indices passed to the corresponding SparseSegmentMean op.
+///     - segment_ids: segment_ids passed to the corresponding SparseSegmentMean op.
+///     - output_dim0: dimension 0 of "data" passed to SparseSegmentMean op.
+@inlinable @inline(__always)
+public static func sparseSegmentMeanGrad<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    grad: Tensor<T>,
+    indices: Tensor<Tidx>,
+    segmentIds: Tensor<Int32>,
+    outputDim0: Tensor<Int32>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseSegmentMeanGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.addInput(segmentIds)
+    op.addInput(outputDim0)
+    return op.execute(Int(1))
+}
+
+/// Computes the mean along sparse segments of a tensor.
+///
+/// Like `SparseSegmentMean`, but allows missing ids in `segment_ids`. If an id is
+/// misisng, the `output` tensor at that position will be zeroed.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// - Parameters:
+///     - indices: A 1-D tensor. Has same rank as `segment_ids`.
+///     - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
+///     - num_segments: Should equal the number of distinct segment IDs.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which has size
+///     `num_segments`.
+@inlinable @inline(__always)
+public static func sparseSegmentMeanWithNumSegments<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    indices: Tensor<Tidx>,
+    segmentIds: Tensor<Int32>,
+    numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseSegmentMeanWithNumSegments", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.updateAttribute("Tnumsegments", Tnumsegments.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(indices)
+    op.addInput(segmentIds)
+    op.addInput(numSegments)
+    return op.execute(Int(1))
+}
+
+/// Computes the sum along sparse segments of a tensor divided by the sqrt of N.
+///
+/// N is the size of the segment being reduced.
+///
+/// See `tf.sparse.segment_sum` for usage examples.
+///
+///
+/// - Parameters:
+///     - indices: A 1-D tensor. Has same rank as `segment_ids`.
+///     - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///     has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func sparseSegmentSqrtN<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    indices: Tensor<Tidx>,
+    segmentIds: Tensor<Int32>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseSegmentSqrtN", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(indices)
+    op.addInput(segmentIds)
+    return op.execute(Int(1))
+}
+
+/// Computes gradients for SparseSegmentSqrtN.
+///
+/// Returns tensor "output" with same shape as grad, except for dimension 0 whose
+/// value is output_dim0.
+///
+/// - Parameters:
+///     - grad: gradient propagated to the SparseSegmentSqrtN op.
+///     - indices: indices passed to the corresponding SparseSegmentSqrtN op.
+///     - segment_ids: segment_ids passed to the corresponding SparseSegmentSqrtN op.
+///     - output_dim0: dimension 0 of "data" passed to SparseSegmentSqrtN op.
+@inlinable @inline(__always)
+public static func sparseSegmentSqrtNGrad<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    grad: Tensor<T>,
+    indices: Tensor<Tidx>,
+    segmentIds: Tensor<Int32>,
+    outputDim0: Tensor<Int32>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseSegmentSqrtNGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(grad)
+    op.addInput(indices)
+    op.addInput(segmentIds)
+    op.addInput(outputDim0)
+    return op.execute(Int(1))
+}
+
+/// Computes the sum along sparse segments of a tensor divided by the sqrt of N.
+///
+/// N is the size of the segment being reduced.
+///
+/// Like `SparseSegmentSqrtN`, but allows missing ids in `segment_ids`. If an id is
+/// misisng, the `output` tensor at that position will be zeroed.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// - Parameters:
+///     - indices: A 1-D tensor. Has same rank as `segment_ids`.
+///     - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
+///     - num_segments: Should equal the number of distinct segment IDs.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///     has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func sparseSegmentSqrtNWithNumSegments<
+    T: FloatingPoint & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    indices: Tensor<Tidx>,
+    segmentIds: Tensor<Int32>,
+    numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseSegmentSqrtNWithNumSegments", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.updateAttribute("Tnumsegments", Tnumsegments.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(indices)
+    op.addInput(segmentIds)
+    op.addInput(numSegments)
+    return op.execute(Int(1))
+}
+
+/// Computes the sum along sparse segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Like `SegmentSum`, but `segment_ids` can have rank less than `data`'s first
+/// dimension, selecting a subset of dimension 0, specified by `indices`.
+///
+/// For example:
+///
+/// ```python
+/// c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
+///
+/// # Select two rows, one segment.
+/// tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))
+/// # => [[0 0 0 0]]
+///
+/// # Select two rows, two segment.
+/// tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))
+/// # => [[ 1  2  3  4]
+/// #     [-1 -2 -3 -4]]
+///
+/// # Select all rows, two segments.
+/// tf.sparse_segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))
+/// # => [[0 0 0 0]
+/// #     [5 6 7 8]]
+///
+/// # Which is equivalent to:
+/// tf.segment_sum(c, tf.constant([0, 0, 1]))
+/// ```
+///
+/// - Parameters:
+///     - indices: A 1-D tensor. Has same rank as `segment_ids`.
+///     - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///     has size `k`, the number of segments.
+@inlinable @inline(__always)
+public static func sparseSegmentSum<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    indices: Tensor<Tidx>,
+    segmentIds: Tensor<Int32>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseSegmentSum", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(indices)
+    op.addInput(segmentIds)
+    return op.execute(Int(1))
+}
+
+/// Computes the sum along sparse segments of a tensor.
+///
+/// Like `SparseSegmentSum`, but allows missing ids in `segment_ids`. If an id is
+/// misisng, the `output` tensor at that position will be zeroed.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/sparse#Segmentation)
+/// for an explanation of segments.
+///
+/// For example:
+///
+/// ```python
+/// c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
+///
+/// tf.sparse_segment_sum_with_num_segments(
+///     c, tf.constant([0, 1]), tf.constant([0, 0]), num_segments=3)
+/// # => [[0 0 0 0]
+/// #     [0 0 0 0]
+/// #     [0 0 0 0]]
+///
+/// tf.sparse_segment_sum_with_num_segments(c,
+///                                         tf.constant([0, 1]),
+///                                         tf.constant([0, 2],
+///                                         num_segments=4))
+/// # => [[ 1  2  3  4]
+/// #     [ 0  0  0  0]
+/// #     [-1 -2 -3 -4]
+/// #     [ 0  0  0  0]]
+/// ```
+///
+/// - Parameters:
+///     - indices: A 1-D tensor. Has same rank as `segment_ids`.
+///     - segment_ids: A 1-D tensor. Values should be sorted and can be repeated.
+///     - num_segments: Should equal the number of distinct segment IDs.
+///
+/// - Output output: Has same shape as data, except for dimension 0 which
+///     has size `num_segments`.
+@inlinable @inline(__always)
+public static func sparseSegmentSumWithNumSegments<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    indices: Tensor<Tidx>,
+    segmentIds: Tensor<Int32>,
+    numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseSegmentSumWithNumSegments", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.updateAttribute("Tnumsegments", Tnumsegments.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(indices)
+    op.addInput(segmentIds)
+    op.addInput(numSegments)
+    return op.execute(Int(1))
+}
+
+/// Slice a `SparseTensor` based on the `start` and `size`.
+///
+/// For example, if the input is
+///
+///     input_tensor = shape = [2, 7]
+///     [    a   d e  ]
+///     [b c          ]
+///
+/// Graphically the output tensors are:
+///
+///     sparse_slice([0, 0], [2, 4]) = shape = [2, 4]
+///     [    a  ]
+///     [b c    ]
+///
+///     sparse_slice([0, 4], [2, 3]) = shape = [2, 3]
+///     [ d e  ]
+///     [      ]
+///
+/// - Parameters:
+///     - indices: 2-D tensor represents the indices of the sparse tensor.
+///     - values: 1-D tensor represents the values of the sparse tensor.
+///     - shape: 1-D. tensor represents the shape of the sparse tensor.
+///     - start: 1-D. tensor represents the start of the slice.
+///     - size: 1-D. tensor represents the size of the slice.
+///         output indices: A list of 1-D tensors represents the indices of the output
+///         sparse tensors.
+///
+/// - Outputs:
+///     - output_values: A list of 1-D tensors represents the values of the output sparse
+///         tensors.
+///     - output_shape: A list of 1-D tensors represents the shape of the output sparse
+///         tensors.
+@inlinable @inline(__always)
+public static func sparseSlice<T: TensorFlowScalar>(
+    indices: Tensor<Int64>,
+    _ values: Tensor<T>,
+    shape: Tensor<Int64>,
+    start: Tensor<Int64>,
+    size: Tensor<Int64>
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>, outputShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("SparseSlice", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(indices)
+    op.addInput(values)
+    op.addInput(shape)
+    op.addInput(start)
+    op.addInput(size)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// The gradient operator for the SparseSlice op.
+///
+/// This op takes in the upstream gradient w.r.t. non-empty values of
+/// the sliced `SparseTensor`, and outputs the gradients w.r.t.
+/// the non-empty values of input `SparseTensor`.
+///
+/// - Parameters:
+///     - backprop_val_grad: 1-D. The gradient with respect to
+///         the non-empty values of the sliced `SparseTensor`.
+///     - input_indices: 2-D.  The `indices` of the input `SparseTensor`.
+///     - input_start: 1-D. tensor represents the start of the slice.
+///     - output_indices: 2-D.  The `indices` of the sliced `SparseTensor`.
+///
+/// - Output val_grad: 1-D. The gradient with respect to the non-empty values of input `SparseTensor`.
+@inlinable @inline(__always)
+public static func sparseSliceGrad<T: Numeric & TensorFlowScalar>(
+    backpropValGrad: Tensor<T>,
+    inputIndices: Tensor<Int64>,
+    inputStart: Tensor<Int64>,
+    outputIndices: Tensor<Int64>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseSliceGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(backpropValGrad)
+    op.addInput(inputIndices)
+    op.addInput(inputStart)
+    op.addInput(outputIndices)
+    return op.execute(Int(1))
+}
+
+/// Applies softmax to a batched N-D `SparseTensor`.
+///
+/// The inputs represent an N-D SparseTensor  with logical shape `[..., B, C]`
+/// (where `N >= 2`), and with indices sorted in the canonical lexicographic order.
+///
+/// This op is equivalent to applying the normal `tf.nn.softmax()` to each innermost
+/// logical submatrix with shape `[B, C]`, but with the catch that *the implicitly
+/// zero elements do not participate*.  Specifically, the algorithm is equivalent
+/// to the following:
+///
+///   (1) Applies `tf.nn.softmax()` to a densified view of each innermost submatrix
+///       with shape `[B, C]`, along the size-C dimension;
+///   (2) Masks out the original implicitly-zero locations;
+///   (3) Renormalizes the remaining elements.
+///
+/// Hence, the `SparseTensor` result has exactly the same non-zero indices and
+/// shape.
+///
+/// - Parameters:
+///     - sp_indices: 2-D.  `NNZ x R` matrix with the indices of non-empty values in a
+///         SparseTensor, in canonical ordering.
+///     - sp_values: 1-D.  `NNZ` non-empty values corresponding to `sp_indices`.
+///     - sp_shape: 1-D.  Shape of the input SparseTensor.
+///
+/// - Output output: 1-D.  The `NNZ` values for the result `SparseTensor`.
+@inlinable @inline(__always)
+public static func sparseSoftmax<T: FloatingPoint & TensorFlowScalar>(
+    spIndices: Tensor<Int64>,
+    spValues: Tensor<T>,
+    spShape: Tensor<Int64>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseSoftmax", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(spIndices)
+    op.addInput(spValues)
+    op.addInput(spShape)
+    return op.execute(Int(1))
+}
+
+/// Computes softmax cross entropy cost and gradients to backpropagate.
+///
+/// Unlike `SoftmaxCrossEntropyWithLogits`, this operation does not accept
+/// a matrix of label probabilities, but rather a single label per row
+/// of features.  This label is considered to have probability 1.0 for the
+/// given row.
+///
+/// Inputs are the logits, not probabilities.
+///
+/// - Parameters:
+///     - features: batch_size x num_classes matrix
+///     - labels: batch_size vector with values in [0, num_classes).
+///         This is the label for the given minibatch entry.
+///
+/// - Outputs:
+///     - loss: Per example loss (batch_size vector).
+///     - backprop: backpropagated gradients (batch_size x num_classes matrix).
+@inlinable @inline(__always)
+public static func sparseSoftmaxCrossEntropyWithLogits<
+    T: FloatingPoint & TensorFlowScalar,
+    Tlabels: BinaryInteger & TensorFlowScalar
+>(
+    features: Tensor<T>,
+    labels: Tensor<Tlabels>
+) -> (loss: Tensor<T>, backprop: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("SparseSoftmaxCrossEntropyWithLogits", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tlabels", Tlabels.tensorFlowDataType)
+    op.addInput(features)
+    op.addInput(labels)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Returns the element-wise max of two SparseTensors.
+///
+/// Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
+///
+/// - Parameters:
+///     - 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.
+///
+/// - Outputs:
+///     - output_indices: 2-D.  The indices of the output SparseTensor.
+///     - output_values: 1-D.  The values of the output SparseTensor.
+@inlinable @inline(__always)
+public static func sparseSparseMaximum<T: Numeric & TensorFlowScalar>(
+    aIndices: Tensor<Int64>,
+    aValues: Tensor<T>,
+    aShape: Tensor<Int64>,
+    bIndices: Tensor<Int64>,
+    bValues: Tensor<T>,
+    bShape: Tensor<Int64>
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("SparseSparseMaximum", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(aIndices)
+    op.addInput(aValues)
+    op.addInput(aShape)
+    op.addInput(bIndices)
+    op.addInput(bValues)
+    op.addInput(bShape)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Returns the element-wise min of two SparseTensors.
+///
+/// Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
+///
+/// - Parameters:
+///     - 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.
+///
+/// - Outputs:
+///     - output_indices: 2-D.  The indices of the output SparseTensor.
+///     - output_values: 1-D.  The values of the output SparseTensor.
+@inlinable @inline(__always)
+public static func sparseSparseMinimum<T: Numeric & TensorFlowScalar>(
+    aIndices: Tensor<Int64>,
+    aValues: Tensor<T>,
+    aShape: Tensor<Int64>,
+    bIndices: Tensor<Int64>,
+    bValues: Tensor<T>,
+    bShape: Tensor<Int64>
+) -> (outputIndices: Tensor<Int64>, outputValues: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("SparseSparseMinimum", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(aIndices)
+    op.addInput(aValues)
+    op.addInput(aShape)
+    op.addInput(bIndices)
+    op.addInput(bValues)
+    op.addInput(bShape)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Split a `SparseTensor` into `num_split` tensors along one dimension.
+///
+/// If the `shape[split_dim]` is not an integer multiple of `num_split`. Slices
+/// `[0 : shape[split_dim] % num_split]` gets one extra dimension.
+/// For example, if `split_dim = 1` and `num_split = 2` and the input is
+///
+///     input_tensor = shape = [2, 7]
+///     [    a   d e  ]
+///     [b c          ]
+///
+/// Graphically the output tensors are:
+///
+///     output_tensor[0] = shape = [2, 4]
+///     [    a  ]
+///     [b c    ]
+///
+///     output_tensor[1] = shape = [2, 3]
+///     [ d e  ]
+///     [      ]
+///
+/// - Parameters:
+///     - split_dim: 0-D.  The dimension along which to split.  Must be in the range
+///         `[0, rank(shape))`.
+///     - indices: 2-D tensor represents the indices of the sparse tensor.
+///     - values: 1-D tensor represents the values of the sparse tensor.
+///     - shape: 1-D. tensor represents the shape of the sparse tensor.
+///         output indices: A list of 1-D tensors represents the indices of the output
+///         sparse tensors.
+///
+/// - Attr num_split: The number of ways to split.
+///
+/// - Outputs:
+///     - output_values: A list of 1-D tensors represents the values of the output sparse
+///         tensors.
+///     - output_shape: A list of 1-D tensors represents the shape of the output sparse
+///         tensors.
+@inlinable @inline(__always)
+public static func sparseSplit<T: TensorFlowScalar>(
+    splitDim: Tensor<Int64>,
+    indices: Tensor<Int64>,
+    _ values: Tensor<T>,
+    shape: Tensor<Int64>,
+    numSplit: Int64
+) -> (outputIndices: [Tensor<Int64>], outputValues: [Tensor<T>], outputShape: [Tensor<Int64>]) {
+  let nOutputs = Int(numSplit) + Int(numSplit) + Int(numSplit)
+    let op = makeOp("SparseSplit", nOutputs)
+    op.updateAttribute("num_split", numSplit)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(splitDim)
+    op.addInput(indices)
+    op.addInput(values)
+    op.addInput(shape)
+    return op.execute(Int(numSplit), Int(numSplit), Int(numSplit))
+}
+
+/// Adds up a `SparseTensor` and a dense `Tensor`, producing a dense `Tensor`.
+///
+/// This Op does not require `a_indices` be sorted in standard lexicographic order.
+///
+/// - Parameters:
+///     - a_indices: 2-D.  The `indices` of the `SparseTensor`, with shape `[nnz, ndims]`.
+///     - a_values: 1-D.  The `values` of the `SparseTensor`, with shape `[nnz]`.
+///     - a_shape: 1-D.  The `shape` of the `SparseTensor`, with shape `[ndims]`.
+///     - b: `ndims`-D Tensor.  With shape `a_shape`.
+@inlinable @inline(__always)
+public static func sparseTensorDenseAdd<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    aIndices: Tensor<Tindices>,
+    aValues: Tensor<T>,
+    aShape: Tensor<Tindices>,
+    _ b: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseTensorDenseAdd", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(aIndices)
+    op.addInput(aValues)
+    op.addInput(aShape)
+    op.addInput(b)
+    return op.execute(Int(1))
+}
+
+/// Multiply SparseTensor (of rank 2) "A" by dense matrix "B".
+///
+/// No validity checking is performed on the indices of A.  However, the following
+/// input format is recommended for optimal behavior:
+///
+/// if adjoint_a == false:
+///   A should be sorted in lexicographically increasing order.  Use SparseReorder
+///   if you're not sure.
+/// if adjoint_a == true:
+///   A should be sorted in order of increasing dimension 1 (i.e., "column major"
+///   order instead of "row major" order).
+///
+/// - Parameters:
+///     - a_indices: 2-D.  The `indices` of the `SparseTensor`, size `[nnz, 2]` Matrix.
+///     - a_values: 1-D.  The `values` of the `SparseTensor`, size `[nnz]` Vector.
+///     - a_shape: 1-D.  The `shape` of the `SparseTensor`, size `[2]` Vector.
+///     - b: 2-D.  A dense Matrix.
+///
+/// - Attrs:
+///     - adjoint_a: Use the adjoint of A in the matrix multiply.  If A is complex, this
+///         is transpose(conj(A)).  Otherwise it's transpose(A).
+///     - adjoint_b: Use the adjoint of B in the matrix multiply.  If B is complex, this
+///         is transpose(conj(B)).  Otherwise it's transpose(B).
+@inlinable @inline(__always)
+public static func sparseTensorDenseMatMul<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    aIndices: Tensor<Tindices>,
+    aValues: Tensor<T>,
+    aShape: Tensor<Int64>,
+    _ b: Tensor<T>,
+    adjointA: Bool = false,
+    adjointB: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseTensorDenseMatMul", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("adjoint_a", adjointA)
+    op.updateAttribute("adjoint_b", adjointB)
+    op.addInput(aIndices)
+    op.addInput(aValues)
+    op.addInput(aShape)
+    op.addInput(b)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that splits a SparseTensor into elements row-wise.
+@inlinable @inline(__always)
+public static func sparseTensorSliceDataset<Tvalues: TensorFlowScalar>(
+    indices: Tensor<Int64>,
+    _ values: Tensor<Tvalues>,
+    denseShape: Tensor<Int64>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseTensorSliceDataset", nOutputs)
+    op.updateAttribute("Tvalues", Tvalues.tensorFlowDataType)
+    op.addInput(indices)
+    op.addInput(values)
+    op.addInput(denseShape)
+    return op.execute(Int(1))
+}
+
+/// Converts a sparse representation into a dense tensor.
+///
+/// Builds an array `dense` with shape `output_shape` such that
+///
+/// ```
+/// # If sparse_indices is scalar
+/// dense[i] = (i == sparse_indices ? sparse_values : default_value)
+///
+/// # If sparse_indices is a vector, then for each i
+/// dense[sparse_indices[i]] = sparse_values[i]
+///
+/// # If sparse_indices is an n by d matrix, then for each i in [0, n)
+/// dense[sparse_indices[i][0], ..., sparse_indices[i][d-1]] = sparse_values[i]
+/// ```
+///
+/// All other values in `dense` are set to `default_value`.  If `sparse_values` is a
+/// scalar, all sparse indices are set to this single value.
+///
+/// Indices should be sorted in lexicographic order, and indices must not
+/// contain any repeats. If `validate_indices` is true, these properties
+/// are checked during execution.
+///
+/// - Parameters:
+///     - sparse_indices: 0-D, 1-D, or 2-D.  `sparse_indices[i]` contains the complete
+///         index where `sparse_values[i]` will be placed.
+///     - output_shape: 1-D.  Shape of the dense output tensor.
+///     - sparse_values: 1-D.  Values corresponding to each row of `sparse_indices`,
+///         or a scalar value to be used for all sparse indices.
+///     - default_value: Scalar value to set for indices not specified in
+///         `sparse_indices`.
+///
+/// - Attr validate_indices: If true, indices are checked to make sure they are sorted in
+///     lexicographic order and that there are no repeats.
+///
+/// - Output dense: Dense output tensor of shape `output_shape`.
+@inlinable @inline(__always)
+public static func sparseToDense<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    sparseIndices: Tensor<Tindices>,
+    outputShape: Tensor<Tindices>,
+    sparseValues: Tensor<T>,
+    defaultValue: Tensor<T>,
+    validateIndices: Bool = true
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SparseToDense", nOutputs)
+    op.updateAttribute("validate_indices", validateIndices)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(sparseIndices)
+    op.addInput(outputShape)
+    op.addInput(sparseValues)
+    op.addInput(defaultValue)
+    return op.execute(Int(1))
+}
+
+/// Applies set operation along last dimension of 2 `SparseTensor` inputs.
+///
+/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+///
+/// If `validate_indices` is `True`, `SparseToSparseSetOperation` validates the
+/// order and range of `set1` and `set2` indices.
+///
+/// Input `set1` is a `SparseTensor` represented by `set1_indices`, `set1_values`,
+/// and `set1_shape`. For `set1` ranked `n`, 1st `n-1` dimensions must be the same
+/// as `set2`. Dimension `n` contains values in a set, duplicates are allowed but
+/// ignored.
+///
+/// Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
+/// and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
+/// as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
+/// ignored.
+///
+/// If `validate_indices` is `True`, this op validates the order and range of `set1`
+/// and `set2` indices.
+///
+/// Output `result` is a `SparseTensor` represented by `result_indices`,
+/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+/// dimension contains the result of `set_operation` applied to the corresponding
+/// `[0...n-1]` dimension of `set`.
+///
+/// - Parameters:
+///     - set1_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+///         order.
+///     - set1_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+///         order.
+///     - set1_shape: 1D `Tensor`, shape of a `SparseTensor`. `set1_shape[0...n-1]` must
+///         be the same as `set2_shape[0...n-1]`, `set1_shape[n]` is the
+///         max set size across `0...n-1` dimensions.
+///     - set2_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+///         order.
+///     - set2_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+///         order.
+///     - set2_shape: 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
+///         be the same as `set1_shape[0...n-1]`, `set2_shape[n]` is the
+///         max set size across `0...n-1` dimensions.
+///
+/// - Outputs:
+///     - result_indices: 2D indices of a `SparseTensor`.
+///     - result_values: 1D values of a `SparseTensor`.
+///     - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+///         the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+///         is the max result set size across all `0...n-1` dimensions.
+@inlinable @inline(__always)
+public static func sparseToSparseSetOperation<T: BinaryInteger & TensorFlowScalar>(
+    set1Indices: Tensor<Int64>,
+    set1Values: Tensor<T>,
+    set1Shape: Tensor<Int64>,
+    set2Indices: Tensor<Int64>,
+    set2Values: Tensor<T>,
+    set2Shape: Tensor<Int64>,
+    setOperation: String,
+    validateIndices: Bool = true
+) -> (resultIndices: Tensor<Int64>, resultValues: Tensor<T>, resultShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("SparseToSparseSetOperation", nOutputs)
+    op.updateAttribute("set_operation", setOperation)
+    op.updateAttribute("validate_indices", validateIndices)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(set1Indices)
+    op.addInput(set1Values)
+    op.addInput(set1Shape)
+    op.addInput(set2Indices)
+    op.addInput(set2Values)
+    op.addInput(set2Shape)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Applies set operation along last dimension of 2 `SparseTensor` inputs.
+///
+/// See SetOperationOp::SetOperationFromContext for values of `set_operation`.
+///
+/// If `validate_indices` is `True`, `SparseToSparseSetOperation` validates the
+/// order and range of `set1` and `set2` indices.
+///
+/// Input `set1` is a `SparseTensor` represented by `set1_indices`, `set1_values`,
+/// and `set1_shape`. For `set1` ranked `n`, 1st `n-1` dimensions must be the same
+/// as `set2`. Dimension `n` contains values in a set, duplicates are allowed but
+/// ignored.
+///
+/// Input `set2` is a `SparseTensor` represented by `set2_indices`, `set2_values`,
+/// and `set2_shape`. For `set2` ranked `n`, 1st `n-1` dimensions must be the same
+/// as `set1`. Dimension `n` contains values in a set, duplicates are allowed but
+/// ignored.
+///
+/// If `validate_indices` is `True`, this op validates the order and range of `set1`
+/// and `set2` indices.
+///
+/// Output `result` is a `SparseTensor` represented by `result_indices`,
+/// `result_values`, and `result_shape`. For `set1` and `set2` ranked `n`, this
+/// has rank `n` and the same 1st `n-1` dimensions as `set1` and `set2`. The `nth`
+/// dimension contains the result of `set_operation` applied to the corresponding
+/// `[0...n-1]` dimension of `set`.
+///
+/// - Parameters:
+///     - set1_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+///         order.
+///     - set1_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+///         order.
+///     - set1_shape: 1D `Tensor`, shape of a `SparseTensor`. `set1_shape[0...n-1]` must
+///         be the same as `set2_shape[0...n-1]`, `set1_shape[n]` is the
+///         max set size across `0...n-1` dimensions.
+///     - set2_indices: 2D `Tensor`, indices of a `SparseTensor`. Must be in row-major
+///         order.
+///     - set2_values: 1D `Tensor`, values of a `SparseTensor`. Must be in row-major
+///         order.
+///     - set2_shape: 1D `Tensor`, shape of a `SparseTensor`. `set2_shape[0...n-1]` must
+///         be the same as `set1_shape[0...n-1]`, `set2_shape[n]` is the
+///         max set size across `0...n-1` dimensions.
+///
+/// - Outputs:
+///     - result_indices: 2D indices of a `SparseTensor`.
+///     - result_values: 1D values of a `SparseTensor`.
+///     - result_shape: 1D `Tensor` shape of a `SparseTensor`. `result_shape[0...n-1]` is
+///         the same as the 1st `n-1` dimensions of `set1` and `set2`, `result_shape[n]`
+///         is the max result set size across all `0...n-1` dimensions.
+@inlinable @inline(__always)
+public static func sparseToSparseSetOperation(
+    set1Indices: Tensor<Int64>,
+    set1Values: StringTensor,
+    set1Shape: Tensor<Int64>,
+    set2Indices: Tensor<Int64>,
+    set2Values: StringTensor,
+    set2Shape: Tensor<Int64>,
+    setOperation: String,
+    validateIndices: Bool = true
+) -> (resultIndices: Tensor<Int64>, resultValues: StringTensor, resultShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("SparseToSparseSetOperation", nOutputs)
+    op.updateAttribute("set_operation", setOperation)
+    op.updateAttribute("validate_indices", validateIndices)
+    op.updateAttribute("T", TensorDataType(TF_STRING))
+    op.addInput(set1Indices)
+    op.addInput(set1Values)
+    op.addInput(set1Shape)
+    op.addInput(set2Indices)
+    op.addInput(set2Values)
+    op.addInput(set2Shape)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Splits a tensor into `num_split` tensors along one dimension.
+///
+/// - Parameters:
+///     - split_dim: 0-D.  The dimension along which to split.  Must be in the range
+///         `[-rank(value), rank(value))`.
+///     - value: The tensor to split.
+///
+/// - Attr num_split: The number of ways to split.  Must evenly divide
+///     `value.shape[split_dim]`.
+///
+/// - Output output: They are identically shaped tensors, whose shape matches that of `value`
+///     except along `axis`, where their sizes are
+///     `values.shape[split_dim] / num_split`.
+@inlinable @inline(__always)
+public static func split<T: TensorFlowScalar>(
+    splitDim: Tensor<Int32>,
+    value: Tensor<T>,
+    numSplit: Int64
+) -> [Tensor<T>] {
+  let nOutputs = Int(numSplit)
+    let op = makeOp("Split", nOutputs)
+    op.updateAttribute("num_split", numSplit)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(splitDim)
+    op.addInput(value)
+    return op.execute(Int(numSplit))
+}
+
+/// Splits a tensor into `num_split` tensors along one dimension.
+///
+/// - Parameters:
+///     - value: The tensor to split.
+///     - size_splits: list containing the sizes of each output tensor along the split
+///         dimension. Must sum to the dimension of value along split_dim.
+///         Can contain one -1 indicating that dimension is to be inferred.
+///     - split_dim: 0-D.  The dimension along which to split.  Must be in the range
+///         `[-rank(value), rank(value))`.
+///
+/// - Output output: Tensors whose shape matches that of `value`
+///     except along `axis`, where their sizes are
+///     `size_splits[i]`.
+@inlinable @inline(__always)
+public static func splitV<
+    T: TensorFlowScalar,
+    Tlen: BinaryInteger & TensorFlowScalar
+>(
+    value: Tensor<T>,
+    sizeSplits: Tensor<Tlen>,
+    splitDim: Tensor<Int32>,
+    numSplit: Int64
+) -> [Tensor<T>] {
+  let nOutputs = Int(numSplit)
+    let op = makeOp("SplitV", nOutputs)
+    op.updateAttribute("num_split", numSplit)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tlen", Tlen.tensorFlowDataType)
+    op.addInput(value)
+    op.addInput(sizeSplits)
+    op.addInput(splitDim)
+    return op.execute(Int(numSplit))
+}
+
+/// Computes square root of x element-wise.
+///
+/// I.e., \\(y = \sqrt{x} = x^{1/2}\\).
+@inlinable @inline(__always)
+public static func sqrt<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Sqrt", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient for the sqrt of `x` wrt its input.
+///
+/// Specifically, `grad = dy * 0.5 / y`, where `y = sqrt(x)`, and `dy`
+/// is the corresponding input gradient.
+@inlinable @inline(__always)
+public static func sqrtGrad<T: FloatingPoint & TensorFlowScalar>(
+    _ y: Tensor<T>,
+    dy: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SqrtGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(y)
+    op.addInput(dy)
+    return op.execute(Int(1))
+}
+
+/// Computes square of x element-wise.
+///
+/// I.e., \\(y = x * x = x^2\\).
+@inlinable @inline(__always)
+public static func square<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Square", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Returns (x - y)(x - y) element-wise.
+///
+/// *NOTE*: `SquaredDifference` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func squaredDifference<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("SquaredDifference", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Removes dimensions of size 1 from the shape of a tensor.
+///
+/// Given a tensor `input`, this operation returns a tensor of the same type with
+/// all dimensions of size 1 removed. If you don't want to remove all size 1
+/// dimensions, you can remove specific size 1 dimensions by specifying
+/// `axis`.
+///
+/// For example:
+///
+/// ```
+/// # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
+/// shape(squeeze(t)) ==> [2, 3]
+/// ```
+///
+/// Or, to remove specific size 1 dimensions:
+///
+/// ```
+/// # 't' is a tensor of shape [1, 2, 1, 3, 1, 1]
+/// shape(squeeze(t, [2, 4])) ==> [1, 2, 3, 1]
+/// ```
+///
+/// - Parameter input: The `input` to squeeze.
+///
+/// - Attr squeeze_dims: If specified, only squeezes the dimensions listed. The dimension
+///     index starts at 0. It is an error to squeeze a dimension that is not 1. Must
+///     be in the range `[-rank(input), rank(input))`.
+///
+/// - Output output: Contains the same data as `input`, but has one or more dimensions of
+///     size 1 removed.
+@inlinable @inline(__always)
+public static func squeeze<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    squeezeDims: [Int32]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Squeeze", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("squeeze_dims", squeezeDims)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Delete the stack from its resource container.
+///
+/// - Parameter handle: The handle to a stack.
+@inlinable @inline(__always)
+public static func stackCloseV2(
+    handle: ResourceHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("StackCloseV2", nOutputs)
+    op.addInput(handle)
+    op.execute()
+}
+
+/// Pop the element at the top of the stack.
+///
+/// - Parameter handle: The handle to a stack.
+///
+/// - Attr elem_type: The type of the elem that is popped.
+///
+/// - Output elem: The tensor that is popped from the top of the stack.
+@inlinable @inline(__always)
+public static func stackPopV2<ElemType: TensorFlowScalar>(
+    handle: ResourceHandle
+) -> Tensor<ElemType> {
+  let nOutputs = Int(1)
+    let op = makeOp("StackPopV2", nOutputs)
+    op.updateAttribute("elem_type", ElemType.tensorFlowDataType)
+    op.addInput(handle)
+    return op.execute(Int(1))
+}
+
+/// Push an element onto the stack.
+///
+/// - Parameters:
+///     - handle: The handle to a stack.
+///     - elem: The tensor to be pushed onto the stack.
+///
+/// - Attr swap_memory: Swap `elem` to CPU. Default to false.
+///
+/// - Output output: The same tensor as the input 'elem'.
+@inlinable @inline(__always)
+public static func stackPushV2<T: TensorFlowScalar>(
+    handle: ResourceHandle,
+    elem: Tensor<T>,
+    swapMemory: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("StackPushV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("swap_memory", swapMemory)
+    op.addInput(handle)
+    op.addInput(elem)
+    return op.execute(Int(1))
+}
+
+/// A stack that produces elements in first-in last-out order.
+///
+/// - Parameter max_size: The maximum size of the stack if non-negative. If negative, the stack
+///     size is unlimited.
+///
+/// - Attrs:
+///     - elem_type: The type of the elements on the stack.
+///     - stack_name: Overrides the name used for the temporary stack resource. Default
+///         value is the name of the 'Stack' op (which is guaranteed unique).
+///
+/// - Output handle: The handle to the stack.
+@inlinable @inline(__always)
+public static func stackV2(
+    maxSize: Tensor<Int32>,
+    elemType: TensorDataType,
+    stackName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("StackV2", nOutputs)
+    op.updateAttribute("elem_type", elemType)
+    op.updateAttribute("stack_name", stackName)
+    op.addInput(maxSize)
+    return op.execute(Int(1))
+}
+
+/// Stage values similar to a lightweight Enqueue.
+///
+/// The basic functionality of this Op is similar to a queue with many
+/// fewer capabilities and options.  This Op is optimized for performance.
+///
+/// - Parameter values: a list of tensors
+///     dtypes A list of data types that inserted values should adhere to.
+///
+/// - Attrs:
+///     - capacity: Maximum number of elements in the Staging Area. If > 0, inserts
+///         on the container will block when the capacity is reached.
+///     - memory_limit: The maximum number of bytes allowed for Tensors in the Staging Area.
+///         If > 0, inserts will block until sufficient space is available.
+///     - container: If non-empty, this queue is placed in the given container. Otherwise,
+///         a default container is used.
+///     - shared_name: It is necessary to match this name to the matching Unstage Op.
+@inlinable @inline(__always)
+public static func stage<Dtypes: TensorArrayProtocol>(
+    _ values: Dtypes,
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    container: String,
+    sharedName: String
+) {
+  let nOutputs = 0
+    let op = makeOp("Stage", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", values._typeList)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInputList(values)
+    op.execute()
+}
+
+/// Op removes all elements in the underlying container.
+@inlinable @inline(__always)
+public static func stageClear(
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    dtypes: [TensorDataType],
+    container: String,
+    sharedName: String
+) {
+  let nOutputs = 0
+    let op = makeOp("StageClear", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", dtypes)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.execute()
+}
+
+/// Op peeks at the values at the specified index.  If the
+///
+/// underlying container does not contain sufficient elements
+/// this op will block until it does.   This Op is optimized for
+/// performance.
+@inlinable @inline(__always)
+public static func stagePeek<Dtypes: TensorGroup>(
+    index: Tensor<Int32>,
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    container: String,
+    sharedName: String
+) -> Dtypes {
+  let nOutputs = Int(Dtypes._typeList.count)
+    let op = makeOp("StagePeek", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", Dtypes._typeList)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(index)
+    return op.execute(Int(Dtypes._typeList.count))
+}
+
+/// Op returns the number of elements in the underlying container.
+@inlinable @inline(__always)
+public static func stageSize(
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    dtypes: [TensorDataType],
+    container: String,
+    sharedName: String
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("StageSize", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", dtypes)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// returns `f(inputs)`, where `f`'s body is placed and partitioned.
+///
+/// - Parameter args: A list of input tensors.
+///
+/// - Attrs:
+///     - Tin: A list of input types.
+///     - Tout: A list of output types.
+///     - f:       A function that takes 'args', a list of tensors, and returns 'output',
+///               another list of tensors. Input and output types are specified by 'Tin'
+///               and 'Tout'. The function body of f will be placed and partitioned across
+///               devices, setting this op apart from the regular Call op. This op is
+///               stateful.
+///
+/// - Output output: A list of return values.
+@inlinable @inline(__always)
+public static func statefulPartitionedCall<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    FIn: TensorGroup,
+    FOut: TensorGroup
+>(
+    args: Tin,
+    f: (FIn) -> FOut,
+    config: String,
+    configProto: String,
+    executorType: String
+) -> Tout {
+  let nOutputs = Int(Tout._typeList.count)
+    let op = makeOp("StatefulPartitionedCall", nOutputs)
+    op.updateAttribute("Tin", args._typeList)
+    op.updateAttribute("Tout", Tout._typeList)
+    op.updateAttribute("f", f)
+    op.updateAttribute("config", config)
+    op.updateAttribute("config_proto", configProto)
+    op.updateAttribute("executor_type", executorType)
+    op.addInputList(args)
+    return op.execute(Int(Tout._typeList.count))
+}
+
+@inlinable @inline(__always)
+public static func statefulRandomBinomial<
+    S: BinaryInteger & TensorFlowScalar,
+    T: Numeric & TensorFlowScalar,
+    Dtype: Numeric & TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    algorithm: Tensor<Int64>,
+    shape: Tensor<S>,
+    counts: Tensor<T>,
+    probs: Tensor<T>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("StatefulRandomBinomial", nOutputs)
+    op.updateAttribute("S", S.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(algorithm)
+    op.addInput(shape)
+    op.addInput(counts)
+    op.addInput(probs)
+    return op.execute(Int(1))
+}
+
+/// Outputs random values from a normal distribution. This op is deprecated in favor of op 'StatefulStandardNormalV2'
+///
+/// The generated values will have mean 0 and standard deviation 1.
+///
+/// - Parameters:
+///     - resource: The handle of the resource variable that stores the state of the RNG.
+///     - shape: The shape of the output tensor.
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: A tensor of the specified shape filled with random normal values.
+@inlinable @inline(__always)
+public static func statefulStandardNormal<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    shape: Tensor<ShapeDtype>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("StatefulStandardNormal", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape_dtype", ShapeDtype.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Outputs random values from a normal distribution.
+///
+/// The generated values will have mean 0 and standard deviation 1.
+///
+/// - Parameters:
+///     - resource: The handle of the resource variable that stores the state of the RNG.
+///     - algorithm: The RNG algorithm.
+///     - shape: The shape of the output tensor.
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: A tensor of the specified shape filled with random normal values.
+@inlinable @inline(__always)
+public static func statefulStandardNormalV2<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    algorithm: Tensor<Int64>,
+    shape: Tensor<ShapeDtype>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("StatefulStandardNormalV2", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape_dtype", ShapeDtype.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(algorithm)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Outputs random values from a truncated normal distribution.
+///
+/// The generated values follow a normal distribution with mean 0 and standard
+/// deviation 1, except that values whose magnitude is more than 2 standard
+/// deviations from the mean are dropped and re-picked.
+///
+/// - Parameters:
+///     - resource: The handle of the resource variable that stores the state of the RNG.
+///     - algorithm: The RNG algorithm.
+///     - shape: The shape of the output tensor.
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statefulTruncatedNormal<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    algorithm: Tensor<Int64>,
+    shape: Tensor<ShapeDtype>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("StatefulTruncatedNormal", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape_dtype", ShapeDtype.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(algorithm)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Outputs random values from a uniform distribution.
+///
+/// The generated values follow a uniform distribution in the range `[0, 1)`. The
+/// lower bound 0 is included in the range, while the upper bound 1 is excluded.
+///
+/// - Parameters:
+///     - resource: The handle of the resource variable that stores the state of the RNG.
+///     - algorithm: The RNG algorithm.
+///     - shape: The shape of the output tensor.
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statefulUniform<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    algorithm: Tensor<Int64>,
+    shape: Tensor<ShapeDtype>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("StatefulUniform", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape_dtype", ShapeDtype.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(algorithm)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Outputs random integers from a uniform distribution.
+///
+/// The generated values are uniform integers covering the whole range of `dtype`. 
+///
+/// - Parameters:
+///     - resource: The handle of the resource variable that stores the state of the RNG.
+///     - algorithm: The RNG algorithm.
+///     - shape: The shape of the output tensor.
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statefulUniformFullInt<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    algorithm: Tensor<Int64>,
+    shape: Tensor<ShapeDtype>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("StatefulUniformFullInt", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape_dtype", ShapeDtype.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(algorithm)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Outputs random integers from a uniform distribution.
+///
+/// The generated values are uniform integers in the range `[minval, maxval)`.
+/// The lower bound `minval` is included in the range, while the upper bound
+/// `maxval` is excluded.
+///
+/// The random integers are slightly biased unless `maxval - minval` is an exact
+/// power of two.  The bias is small for values of `maxval - minval` significantly
+/// smaller than the range of the output (either `2^32` or `2^64`).
+///
+/// - Parameters:
+///     - resource: The handle of the resource variable that stores the state of the RNG.
+///     - algorithm: The RNG algorithm.
+///     - shape: The shape of the output tensor.
+///     - minval: Minimum value (inclusive, scalar).
+///     - maxval: Maximum value (exclusive, scalar).
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statefulUniformInt<
+    Dtype: TensorFlowScalar,
+    ShapeDtype: TensorFlowScalar
+>(
+    resource: ResourceHandle,
+    algorithm: Tensor<Int64>,
+    shape: Tensor<ShapeDtype>,
+    minval: Tensor<Dtype>,
+    maxval: Tensor<Dtype>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("StatefulUniformInt", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("shape_dtype", ShapeDtype.tensorFlowDataType)
+    op.addInput(resource)
+    op.addInput(algorithm)
+    op.addInput(shape)
+    op.addInput(minval)
+    op.addInput(maxval)
+    return op.execute(Int(1))
+}
+
+/// output = cond ? then_branch(input) : else_branch(input)
+///
+/// - Parameters:
+///     - cond:       A Tensor. If the tensor is a scalar of non-boolean type, the
+///               scalar is converted to a boolean according to the
+///               following rule: if the scalar is a numerical value, non-zero means
+///               `True` and zero means False; if the scalar is a string, non-empty
+///               means `True` and empty means `False`. If the tensor is not a scalar,
+///               being empty means False and being non-empty means True.
+///
+///               This should only be used when the if then/else body functions do not
+///               have stateful ops.
+///     - input: A list of input tensors.
+///
+/// - Attrs:
+///     - Tin: A list of input types.
+///     - Tout: A list of output types.
+///     - then_branch:       A function that takes 'inputs' and returns a list of tensors, whose
+///               types are the same as what else_branch returns.
+///     - else_branch:     A function that takes 'inputs' and returns a list of tensors, whose
+///             types are the same as what then_branch returns.
+///
+/// - Output output: A list of return values.
+@inlinable @inline(__always)
+public static func statelessIf<
+    Tcond: TensorFlowScalar,
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    ThenbranchIn: TensorGroup,
+    ThenbranchOut: TensorGroup,
+    ElsebranchIn: TensorGroup,
+    ElsebranchOut: TensorGroup
+>(
+    cond: Tensor<Tcond>,
+    _ input: Tin,
+    thenBranch: (ThenbranchIn) -> ThenbranchOut,
+    elseBranch: (ElsebranchIn) -> ElsebranchOut
+) -> Tout {
+  let nOutputs = Int(Tout._typeList.count)
+    let op = makeOp("StatelessIf", nOutputs)
+    op.updateAttribute("Tcond", Tcond.tensorFlowDataType)
+    op.updateAttribute("Tin", input._typeList)
+    op.updateAttribute("Tout", Tout._typeList)
+    op.updateAttribute("then_branch", thenBranch)
+    op.updateAttribute("else_branch", elseBranch)
+    op.addInput(cond)
+    op.addInputList(input)
+    return op.execute(Int(Tout._typeList.count))
+}
+
+/// Draws samples from a multinomial distribution.
+///
+/// - Parameters:
+///     - logits: 2-D Tensor with shape `[batch_size, num_classes]`.  Each slice `[i, :]`
+///         represents the unnormalized log probabilities for all classes.
+///     - num_samples: 0-D.  Number of independent samples to draw for each row slice.
+///     - seed: 2 seeds (shape [2]).
+///
+/// - Output output: 2-D Tensor with shape `[batch_size, num_samples]`.  Each slice `[i, :]`
+///     contains the drawn class labels with range `[0, num_classes)`.
+@inlinable @inline(__always)
+public static func statelessMultinomial<
+    T: Numeric & TensorFlowScalar,
+    Tseed: BinaryInteger & TensorFlowScalar,
+    OutputDtype: BinaryInteger & TensorFlowScalar
+>(
+    logits: Tensor<T>,
+    numSamples: Tensor<Int32>,
+    seed: Tensor<Tseed>
+) -> Tensor<OutputDtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("StatelessMultinomial", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tseed", Tseed.tensorFlowDataType)
+    op.updateAttribute("output_dtype", OutputDtype.tensorFlowDataType)
+    op.addInput(logits)
+    op.addInput(numSamples)
+    op.addInput(seed)
+    return op.execute(Int(1))
+}
+
+/// Outputs deterministic pseudorandom values from a normal distribution.
+///
+/// The generated values will have mean 0 and standard deviation 1.
+///
+/// The outputs are a deterministic function of `shape` and `seed`.
+///
+/// - Parameters:
+///     - shape: The shape of the output tensor.
+///     - seed: 2 seeds (shape [2]).
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statelessRandomNormal<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar,
+    Tseed: BinaryInteger & TensorFlowScalar
+>(
+    shape: Tensor<T>,
+    seed: Tensor<Tseed>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("StatelessRandomNormal", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tseed", Tseed.tensorFlowDataType)
+    op.addInput(shape)
+    op.addInput(seed)
+    return op.execute(Int(1))
+}
+
+/// Outputs deterministic pseudorandom random values from a uniform distribution.
+///
+/// The generated values follow a uniform distribution in the range `[0, 1)`. The
+/// lower bound 0 is included in the range, while the upper bound 1 is excluded.
+///
+/// The outputs are a deterministic function of `shape` and `seed`.
+///
+/// - Parameters:
+///     - shape: The shape of the output tensor.
+///     - seed: 2 seeds (shape [2]).
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statelessRandomUniform<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar,
+    Tseed: BinaryInteger & TensorFlowScalar
+>(
+    shape: Tensor<T>,
+    seed: Tensor<Tseed>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("StatelessRandomUniform", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tseed", Tseed.tensorFlowDataType)
+    op.addInput(shape)
+    op.addInput(seed)
+    return op.execute(Int(1))
+}
+
+/// Outputs deterministic pseudorandom random integers from a uniform distribution.
+///
+/// The generated values follow a uniform distribution in the range `[minval, maxval)`.
+///
+/// The outputs are a deterministic function of `shape`, `seed`, `minval`, and `maxval`.
+///
+/// - Parameters:
+///     - shape: The shape of the output tensor.
+///     - seed: 2 seeds (shape [2]).
+///     - minval: Minimum value (inclusive, scalar).
+///     - maxval: Maximum value (exclusive, scalar).
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statelessRandomUniformInt<
+    Dtype: BinaryInteger & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar,
+    Tseed: BinaryInteger & TensorFlowScalar
+>(
+    shape: Tensor<T>,
+    seed: Tensor<Tseed>,
+    minval: Tensor<Dtype>,
+    maxval: Tensor<Dtype>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("StatelessRandomUniformInt", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tseed", Tseed.tensorFlowDataType)
+    op.addInput(shape)
+    op.addInput(seed)
+    op.addInput(minval)
+    op.addInput(maxval)
+    return op.execute(Int(1))
+}
+
+/// Outputs deterministic pseudorandom values from a truncated normal distribution.
+///
+/// The generated values follow a normal distribution with mean 0 and standard
+/// deviation 1, except that values whose magnitude is more than 2 standard
+/// deviations from the mean are dropped and re-picked.
+///
+/// The outputs are a deterministic function of `shape` and `seed`.
+///
+/// - Parameters:
+///     - shape: The shape of the output tensor.
+///     - seed: 2 seeds (shape [2]).
+///
+/// - Attr dtype: The type of the output.
+///
+/// - Output output: Random values with specified shape.
+@inlinable @inline(__always)
+public static func statelessTruncatedNormal<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar,
+    Tseed: BinaryInteger & TensorFlowScalar
+>(
+    shape: Tensor<T>,
+    seed: Tensor<Tseed>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("StatelessTruncatedNormal", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tseed", Tseed.tensorFlowDataType)
+    op.addInput(shape)
+    op.addInput(seed)
+    return op.execute(Int(1))
+}
+
+/// output = input; While (Cond(output)) { output = Body(output) }
+///
+/// - Parameter input: A list of input tensors whose types are T.
+///
+/// - Attrs:
+///     - T: dtype in use.
+///     - cond:       A function takes 'input' and returns a tensor.  If the tensor is
+///               a scalar of non-boolean, the scalar is converted to a boolean
+///               according to the following rule: if the scalar is a numerical
+///               value, non-zero means True and zero means False; if the scalar is
+///               a string, non-empty means True and empty means False. If the
+///               tensor is not a scalar, non-emptiness means True and False
+///               otherwise.
+///
+///               This should only be used when the while condition and body functions
+///               do not have stateful ops.
+///     - body:       A function that takes a list of tensors and returns another
+///               list of tensors. Both lists have the same types as specified
+///               by T.
+///
+/// - Output output: A list of output tensors whose types are T.
+@inlinable @inline(__always)
+public static func statelessWhile<
+    T: TensorArrayProtocol,
+    CondIn: TensorGroup,
+    CondOut: TensorGroup,
+    BodyIn: TensorGroup,
+    BodyOut: TensorGroup
+>(
+    _ input: T,
+    cond: (CondIn) -> CondOut,
+    body: (BodyIn) -> BodyOut
+) -> T {
+  let nOutputs = Int(input._typeList.count)
+    let op = makeOp("StatelessWhile", nOutputs)
+    op.updateAttribute("T", input._typeList)
+    op.updateAttribute("cond", cond)
+    op.updateAttribute("body", body)
+    op.addInputList(input)
+    return op.execute(Int(input._typeList.count))
+}
+
+/// Check if the input matches the regex pattern.
+///
+/// The input is a string tensor of any shape. The pattern is the
+/// regular expression to be matched with every element of the input tensor.
+/// The boolean values (True or False) of the output tensor indicate
+/// if the input matches the regex pattern provided.
+///
+/// The pattern follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
+///
+/// - Parameter input: A string tensor of the text to be processed.
+///
+/// - Attr pattern: The regular expression to match the input.
+///
+/// - Output output: A bool tensor with the same shape as `input`.
+@inlinable @inline(__always)
+public static func staticRegexFullMatch(
+    _ input: StringTensor,
+    pattern: String
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("StaticRegexFullMatch", nOutputs)
+    op.updateAttribute("pattern", pattern)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Replaces the match of pattern in input with rewrite.
+///
+/// It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax)
+///
+/// - Parameter input: The text to be processed.
+///
+/// - Attrs:
+///     - pattern: The regular expression to match the input.
+///     - rewrite: The rewrite to be applied to the matched expression.
+///     - replace_global: If True, the replacement is global, otherwise the replacement
+///         is done only on the first match.
+///
+/// - Output output: The text after applying pattern and rewrite.
+@inlinable @inline(__always)
+public static func staticRegexReplace(
+    _ input: StringTensor,
+    pattern: String,
+    rewrite: String,
+    replaceGlobal: Bool = true
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("StaticRegexReplace", nOutputs)
+    op.updateAttribute("pattern", pattern)
+    op.updateAttribute("rewrite", rewrite)
+    op.updateAttribute("replace_global", replaceGlobal)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func statsAggregatorHandleV2(
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("StatsAggregatorHandleV2", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Set a summary_writer_interface to record statistics using given stats_aggregator.
+@inlinable @inline(__always)
+public static func statsAggregatorSetSummaryWriter(
+    statsAggregator: ResourceHandle,
+    summary: ResourceHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("StatsAggregatorSetSummaryWriter", nOutputs)
+    op.addInput(statsAggregator)
+    op.addInput(summary)
+    op.execute()
+}
+
+/// 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.
+@inlinable @inline(__always)
+public static func stopGradient<T: TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("StopGradient", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Return a strided slice from `input`.
+///
+/// Note, most python users will want to use the Python `Tensor.__getitem__`
+/// or `Variable.__getitem__` rather than this op directly.
+///
+/// The goal of this op is to produce a new tensor with a subset of
+/// the elements from the `n` dimensional `input` tensor. The subset is chosen using
+/// a sequence of `m` sparse range specifications encoded into the arguments
+/// of this function. Note, in some cases
+/// `m` could be equal to `n`, but this need not be the case. Each
+/// range specification entry can be one of the following:
+///
+/// - An ellipsis (...). Ellipses are used to imply zero or more
+///   dimensions of full-dimension selection and are produced using
+///   `ellipsis_mask`. For example, `foo[...]` is the identity slice.
+///
+/// - A new axis. This is used to insert a new shape=1 dimension and is
+///   produced using `new_axis_mask`. For example, `foo[:, ...]` where
+///   `foo` is shape `(3, 4)` produces a `(1, 3, 4)` tensor.
+///
+///
+/// - A range `begin:end:stride`. This is used to specify how much to choose from
+///   a given dimension. `stride` can be any integer but 0.  `begin` is an integer
+///   which represents the index of the first value to select while `end` represents
+///   the index of the last value to select. The number of values selected in each
+///   dimension is `end - begin` if `stride > 0` and `begin - end` if `stride < 0`.
+///   `begin` and `end` can be negative where `-1` is the last element, `-2` is
+///   the second to last. `begin_mask` controls whether to replace the explicitly
+///   given `begin` with an implicit effective value of `0` if `stride > 0` and
+///   `-1` if `stride < 0`. `end_mask` is analogous but produces the number
+///   required to create the largest open interval. For example, given a shape
+///   `(3,)` tensor `foo[:]`, the effective `begin` and `end` are `0` and `3`. Do
+///   not assume this is equivalent to `foo[0:-1]` which has an effective `begin`
+///   and `end` of `0` and `2`. Another example is `foo[-2::-1]` which reverses the
+///   first dimension of a tensor while dropping the last two (in the original
+///   order elements). For example `foo = [1,2,3,4]; foo[-2::-1]` is `[4,3]`.
+///
+/// - A single index. This is used to keep only elements that have a given
+///   index. For example (`foo[2, :]` on a shape `(5,6)` tensor produces a
+///   shape `(6,)` tensor. This is encoded in `begin` and `end` and
+///   `shrink_axis_mask`.
+///
+/// Each conceptual range specification is encoded in the op's argument. This
+/// encoding is best understand by considering a non-trivial example. In
+/// particular,
+/// `foo[1, 2:4, None, ..., :-3:-1, :]` will be encoded as
+///
+/// ```
+/// begin = [1, 2, x, x, 0, x] # x denotes don't care (usually 0)
+/// end = [2, 4, x, x, -3, x]
+/// strides = [1, 1, x, x, -1, 1]
+/// begin_mask = 1<<4 | 1 << 5 = 48
+/// end_mask = 1<<5 = 32
+/// ellipsis_mask = 1<<3 = 8
+/// new_axis_mask = 1<<2 4
+/// shrink_axis_mask = 1<<0
+/// ```
+///
+/// In this case if `foo.shape` is (5, 5, 5, 5, 5, 5) the final shape of
+/// the slice becomes (2, 1, 5, 5, 2, 5).
+/// Let us walk step by step through each argument specification.
+///
+/// 1.  The first argument in the example slice is turned into `begin = 1` and
+/// `end = begin + 1 = 2`. To disambiguate from the original spec `2:4` we
+/// also set the appropriate bit in `shrink_axis_mask`.
+///
+/// 2. `2:4` is contributes 2, 4, 1 to begin, end, and stride. All masks have
+/// zero bits contributed.
+///
+/// 3. None is a synonym for `tf.newaxis`. This means insert a dimension of size 1
+/// dimension in the final shape. Dummy values are contributed to begin,
+/// end and stride, while the new_axis_mask bit is set.
+///
+/// 4. `...` grab the full ranges from as many dimensions as needed to
+/// fully specify a slice for every dimension of the input shape.
+///
+/// 5. `:-3:-1` shows the use of negative indices. A negative index `i` associated
+/// with a dimension that has shape `s` is converted to a positive index
+/// `s + i`. So `-1` becomes `s-1` (i.e. the last element). This conversion
+/// is done internally so begin, end and strides receive x, -3, and -1.
+/// The appropriate begin_mask bit is set to indicate the start range is the
+/// full range (ignoring the x).
+///
+/// 6. `:` indicates that the entire contents of the corresponding dimension
+/// is selected. This is equivalent to `::` or `0::1`. begin, end, and strides
+/// receive 0, 0, and 1, respectively. The appropriate bits in `begin_mask` and
+/// `end_mask` are also set.
+///
+/// *Requirements*:
+///   `0 != strides[i] for i in [0, m)`
+///   `ellipsis_mask must be a power of two (only one ellipsis)`
+///
+/// - Parameters:
+///     - begin: `begin[k]` specifies the offset into the `k`th range specification.
+///         The exact dimension this corresponds to will be determined by context.
+///         Out-of-bounds values will be silently clamped. If the `k`th bit of
+///         `begin_mask` then `begin[k]` is ignored and the full range of the
+///         appropriate dimension is used instead. Negative values causes indexing
+///         to start from the highest element e.g. If `foo==[1,2,3]` then `foo[-1]==3`.
+///     - end: `end[i]` is like `begin` with the exception that `end_mask` is
+///         used to determine full ranges.
+///     - strides: `strides[i]` specifies the increment in the `i`th specification
+///         after extracting a given element. Negative indices will reverse
+///         the original order. Out or range values are
+///         clamped to `[0,dim[i]) if slice[i]>0` or `[-1,dim[i]-1] if slice[i] < 0`
+///
+/// - Attrs:
+///     - begin_mask: a bitmask where a bit i being 1 means to ignore the begin
+///         value and instead use the largest interval possible. At runtime
+///         begin[i] will be replaced with `[0, n-1)` if `stride[i] > 0` or
+///         `[-1, n-1]` if `stride[i] < 0`
+///     - end_mask: analogous to `begin_mask`
+///     - ellipsis_mask: a bitmask where bit `i` being 1 means the `i`th
+///         position is actually an ellipsis. One bit at most can be 1.
+///         If `ellipsis_mask == 0`, then an implicit ellipsis mask of `1 << (m+1)`
+///         is provided. This means that `foo[3:5] == foo[3:5, ...]`. An ellipsis
+///         implicitly creates as many range specifications as necessary to fully
+///         specify the sliced range for every dimension. For example for a 4-dimensional
+///         tensor `foo` the slice `foo[2, ..., 5:8]` implies `foo[2, :, :, 5:8]`.
+///     - new_axis_mask: a bitmask where bit `i` being 1 means the `i`th
+///         specification creates a new shape 1 dimension. For example
+///         `foo[:4, tf.newaxis, :2]` would produce a shape `(4, 1, 2)` tensor.
+///     - shrink_axis_mask: a bitmask where bit `i` implies that the `i`th
+///         specification should shrink the dimensionality. begin and end
+///         must imply a slice of size 1 in the dimension. For example in
+///         python one might do `foo[:, 3, :]` which would result in
+///         `shrink_axis_mask` being 2.
+@inlinable @inline(__always)
+public static func stridedSlice<
+    T: TensorFlowScalar,
+    Index: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    begin: Tensor<Index>,
+    end: Tensor<Index>,
+    strides: Tensor<Index>,
+    beginMask: Int64 = 0,
+    endMask: Int64 = 0,
+    ellipsisMask: Int64 = 0,
+    newAxisMask: Int64 = 0,
+    shrinkAxisMask: Int64 = 0
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("StridedSlice", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Index", Index.tensorFlowDataType)
+    op.updateAttribute("begin_mask", beginMask)
+    op.updateAttribute("end_mask", endMask)
+    op.updateAttribute("ellipsis_mask", ellipsisMask)
+    op.updateAttribute("new_axis_mask", newAxisMask)
+    op.updateAttribute("shrink_axis_mask", shrinkAxisMask)
+    op.addInput(input)
+    op.addInput(begin)
+    op.addInput(end)
+    op.addInput(strides)
+    return op.execute(Int(1))
+}
+
+/// Returns the gradient of `StridedSlice`.
+///
+/// Since `StridedSlice` cuts out pieces of its `input` which is size
+/// `shape`, its gradient will have the same shape (which is passed here
+/// as `shape`). The gradient will be zero in any element that the slice
+/// does not select.
+///
+/// Arguments are the same as StridedSliceGrad with the exception that
+/// `dy` is the input gradient to be propagated and `shape` is the
+/// shape of `StridedSlice`'s `input`.
+@inlinable @inline(__always)
+public static func stridedSliceGrad<
+    T: TensorFlowScalar,
+    Index: BinaryInteger & TensorFlowScalar
+>(
+    shape: Tensor<Index>,
+    begin: Tensor<Index>,
+    end: Tensor<Index>,
+    strides: Tensor<Index>,
+    dy: Tensor<T>,
+    beginMask: Int64 = 0,
+    endMask: Int64 = 0,
+    ellipsisMask: Int64 = 0,
+    newAxisMask: Int64 = 0,
+    shrinkAxisMask: Int64 = 0
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("StridedSliceGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Index", Index.tensorFlowDataType)
+    op.updateAttribute("begin_mask", beginMask)
+    op.updateAttribute("end_mask", endMask)
+    op.updateAttribute("ellipsis_mask", ellipsisMask)
+    op.updateAttribute("new_axis_mask", newAxisMask)
+    op.updateAttribute("shrink_axis_mask", shrinkAxisMask)
+    op.addInput(shape)
+    op.addInput(begin)
+    op.addInput(end)
+    op.addInput(strides)
+    op.addInput(dy)
+    return op.execute(Int(1))
+}
+
+/// Formats a string template using a list of tensors.
+///
+/// Formats a string template using a list of tensors, pretty-printing tensor summaries.
+///
+/// - Parameter inputs: The list of tensors to format into the placeholder string.
+///
+/// - Attrs:
+///     - template: A string, the template to format tensor summaries into.
+///     - placeholder: A string, at each placeholder in the template a subsequent tensor summary will be inserted.
+///     - summarize: When formatting the tensor summaries print the first and last summarize entries of each tensor dimension.
+///
+/// - Output output: = The resulting string scalar.
+@inlinable @inline(__always)
+public static func stringFormat<T: TensorArrayProtocol>(
+    inputs: T,
+    template: String = "%s",
+    placeholder: String = "%s",
+    summarize: Int64 = 3
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("StringFormat", nOutputs)
+    op.updateAttribute("T", inputs._typeList)
+    op.updateAttribute("template", template)
+    op.updateAttribute("placeholder", placeholder)
+    op.updateAttribute("summarize", summarize)
+    op.addInputList(inputs)
+    return op.execute(Int(1))
+}
+
+/// Joins the strings in the given list of string tensors into one tensor;
+///
+/// with the given separator (default is an empty separator).
+///
+/// - Parameter inputs: A list of string tensors.  The tensors must all have the same shape,
+///     or be scalars.  Scalars may be mixed in; these will be broadcast to the shape
+///     of non-scalar inputs.
+///
+/// - Attr separator: string, an optional join separator.
+@inlinable @inline(__always)
+public static func stringJoin(
+    inputs: [StringTensor],
+    separator: String
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("StringJoin", nOutputs)
+    op.updateAttribute("N", inputs.count)
+    op.updateAttribute("separator", separator)
+    op.addInputList(inputs)
+    return op.execute(Int(1))
+}
+
+/// String lengths of `input`.
+///
+/// Computes the length of each string given in the input tensor.
+///
+/// - Parameter input: The string for which to compute the length.
+///
+/// - Attr unit: The unit that is counted to compute string length.  One of: `"BYTE"` (for
+///     the number of bytes in each string) or `"UTF8_CHAR"` (for the number of UTF-8
+///     encoded Unicode code points in each string).  Results are undefined
+///     if `unit=UTF8_CHAR` and the `input` strings do not contain structurally
+///     valid UTF-8.
+///
+/// - Output output: Integer tensor that has the same shape as `input`. The output contains the
+///     element-wise string lengths of `input`.
+@inlinable @inline(__always)
+public static func stringLength(
+    _ input: StringTensor,
+    unit: Unit = .byte
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("StringLength", nOutputs)
+    op.updateAttribute("unit", unit.cName)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func stringListAttr(
+    _ a: [String],
+    _ b: String
+) {
+  let nOutputs = 0
+    let op = makeOp("StringListAttr", nOutputs)
+    op.updateAttribute("a", a)
+    op.updateAttribute("b", b)
+    op.execute()
+}
+
+/// Split elements of `input` based on `delimiter` into a `SparseTensor`.
+///
+/// Let N be the size of source (typically N will be the batch size). Split each
+/// element of `input` based on `delimiter` and return a `SparseTensor`
+/// containing the splitted tokens. Empty tokens are ignored.
+///
+/// `delimiter` can be empty, or a string of split characters. If `delimiter` is an
+///  empty string, each element of `input` is split into individual single-byte
+///  character strings, including splitting of UTF-8 multibyte sequences. Otherwise
+///  every character of `delimiter` is a potential split point.
+///
+/// For example:
+///   N = 2, input[0] is 'hello world' and input[1] is 'a b c', then the output
+///   will be
+///
+///   indices = [0, 0;
+///              0, 1;
+///              1, 0;
+///              1, 1;
+///              1, 2]
+///   shape = [2, 3]
+///   values = ['hello', 'world', 'a', 'b', 'c']
+///
+/// - Parameters:
+///     - input: 1-D. Strings to split.
+///     - delimiter: 0-D. Delimiter characters (bytes), or empty string.
+///
+/// - Attr skip_empty: A `bool`. If `True`, skip the empty strings from the result.
+///
+/// - Outputs:
+///     - indices: A dense matrix of int64 representing the indices of the sparse tensor.
+///     - values: A vector of strings corresponding to the splited values.
+///     - shape: a length-2 vector of int64 representing the shape of the sparse
+///         tensor, where the first value is N and the second value is the maximum number
+///         of tokens in a single input entry.
+@inlinable @inline(__always)
+public static func stringSplit(
+    _ input: StringTensor,
+    delimiter: StringTensor,
+    skipEmpty: Bool = true
+) -> (indices: Tensor<Int64>, values: StringTensor, shape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("StringSplit", nOutputs)
+    op.updateAttribute("skip_empty", skipEmpty)
+    op.addInput(input)
+    op.addInput(delimiter)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Split elements of `source` based on `sep` into a `SparseTensor`.
+///
+/// Let N be the size of source (typically N will be the batch size). Split each
+/// element of `source` based on `sep` and return a `SparseTensor`
+/// containing the split tokens. Empty tokens are ignored.
+///
+/// For example, N = 2, source[0] is 'hello world' and source[1] is 'a b c',
+/// then the output will be
+/// ```
+/// st.indices = [0, 0;
+///               0, 1;
+///               1, 0;
+///               1, 1;
+///               1, 2]
+/// st.shape = [2, 3]
+/// st.values = ['hello', 'world', 'a', 'b', 'c']
+/// ```
+///
+/// If `sep` is given, consecutive delimiters are not grouped together and are
+/// deemed to delimit empty strings. For example, source of `"1<>2<><>3"` and
+/// sep of `"<>"` returns `["1", "2", "", "3"]`. If `sep` is None or an empty
+/// string, consecutive whitespace are regarded as a single separator, and the
+/// result will contain no empty strings at the startor end if the string has
+/// leading or trailing whitespace.
+///
+/// Note that the above mentioned behavior matches python's str.split.
+///
+/// - Parameters:
+///     - input: `1-D` string `Tensor`, the strings to split.
+///     - sep: `0-D` string `Tensor`, the delimiter character.
+///
+/// - Attr maxsplit: An `int`. If `maxsplit > 0`, limit of the split of the result.
+@inlinable @inline(__always)
+public static func stringSplitV2(
+    _ input: StringTensor,
+    sep: StringTensor,
+    maxsplit: Int64 = -1
+) -> (indices: Tensor<Int64>, values: StringTensor, shape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("StringSplitV2", nOutputs)
+    op.updateAttribute("maxsplit", maxsplit)
+    op.addInput(input)
+    op.addInput(sep)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Strip leading and trailing whitespaces from the Tensor.
+///
+/// - Parameter input: A string `Tensor` of any shape.
+///
+/// - Output output: A string `Tensor` of the same shape as the input.
+@inlinable @inline(__always)
+public static func stringStrip(
+    _ input: StringTensor
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("StringStrip", nOutputs)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Converts each string in the input Tensor to its hash mod by a number of buckets.
+///
+/// The hash function is deterministic on the content of the string within the
+/// process.
+///
+/// Note that the hash function may change from time to time.
+/// This functionality will be deprecated and it's recommended to use
+/// `tf.string_to_hash_bucket_fast()` or `tf.string_to_hash_bucket_strong()`.
+///
+/// - Attr num_buckets: The number of buckets.
+///
+/// - Output output: A Tensor of the same shape as the input `string_tensor`.
+@inlinable @inline(__always)
+public static func stringToHashBucket(
+    stringTensor: StringTensor,
+    numBuckets: Int64
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("StringToHashBucket", nOutputs)
+    op.updateAttribute("num_buckets", numBuckets)
+    op.addInput(stringTensor)
+    return op.execute(Int(1))
+}
+
+/// Converts each string in the input Tensor to its hash mod by a number of buckets.
+///
+/// The hash function is deterministic on the content of the string within the
+/// process and will never change. However, it is not suitable for cryptography.
+/// This function may be used when CPU time is scarce and inputs are trusted or
+/// unimportant. There is a risk of adversaries constructing inputs that all hash
+/// to the same bucket. To prevent this problem, use a strong hash function with
+/// `tf.string_to_hash_bucket_strong`.
+///
+/// - Parameter input: The strings to assign a hash bucket.
+///
+/// - Attr num_buckets: The number of buckets.
+///
+/// - Output output: A Tensor of the same shape as the input `string_tensor`.
+@inlinable @inline(__always)
+public static func stringToHashBucketFast(
+    _ input: StringTensor,
+    numBuckets: Int64
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("StringToHashBucketFast", nOutputs)
+    op.updateAttribute("num_buckets", numBuckets)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Converts each string in the input Tensor to its hash mod by a number of buckets.
+///
+/// The hash function is deterministic on the content of the string within the
+/// process. The hash function is a keyed hash function, where attribute `key`
+/// defines the key of the hash function. `key` is an array of 2 elements.
+///
+/// A strong hash is important when inputs may be malicious, e.g. URLs with
+/// additional components. Adversaries could try to make their inputs hash to the
+/// same bucket for a denial-of-service attack or to skew the results. A strong
+/// hash prevents this by making it difficult, if not infeasible, to compute inputs
+/// that hash to the same bucket. This comes at a cost of roughly 4x higher compute
+/// time than `tf.string_to_hash_bucket_fast`.
+///
+/// - Parameter input: The strings to assign a hash bucket.
+///
+/// - Attrs:
+///     - num_buckets: The number of buckets.
+///     - key: The key for the keyed hash function passed as a list of two uint64
+///         elements.
+///
+/// - Output output: A Tensor of the same shape as the input `string_tensor`.
+@inlinable @inline(__always)
+public static func stringToHashBucketStrong(
+    _ input: StringTensor,
+    numBuckets: Int64,
+    key: [Int32]
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("StringToHashBucketStrong", nOutputs)
+    op.updateAttribute("num_buckets", numBuckets)
+    op.updateAttribute("key", key)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Converts each string in the input Tensor to the specified numeric type.
+///
+/// (Note that int32 overflow results in an error while float overflow
+/// results in a rounded value.)
+///
+/// - Attr out_type: The numeric type to interpret each string in `string_tensor` as.
+///
+/// - Output output: A Tensor of the same shape as the input `string_tensor`.
+@inlinable @inline(__always)
+public static func stringToNumber<OutType: Numeric & TensorFlowScalar>(
+    stringTensor: StringTensor
+) -> Tensor<OutType> {
+  let nOutputs = Int(1)
+    let op = makeOp("StringToNumber", nOutputs)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(stringTensor)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func stubResourceHandleOp(
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("StubResourceHandleOp", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Returns x - y element-wise.
+///
+/// *NOTE*: `Subtract` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func sub<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Sub", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Return substrings from `Tensor` of strings.
+///
+/// For each string in the input `Tensor`, creates a substring starting at index
+/// `pos` with a total length of `len`.
+///
+/// If `len` defines a substring that would extend beyond the length of the input
+/// string, then as many characters as possible are used.
+///
+/// A negative `pos` indicates distance within the string backwards from the end.
+///
+/// If `pos` specifies an index which is out of range for any of the input strings,
+/// then an `InvalidArgumentError` is thrown.
+///
+/// `pos` and `len` must have the same shape, otherwise a `ValueError` is thrown on
+/// Op creation.
+///
+/// *NOTE*: `Substr` supports broadcasting up to two dimensions. More about
+/// broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+///
+/// ---
+///
+/// Examples
+///
+/// Using scalar `pos` and `len`:
+///
+/// ```python
+/// input = [b'Hello', b'World']
+/// position = 1
+/// length = 3
+///
+/// output = [b'ell', b'orl']
+/// ```
+///
+/// Using `pos` and `len` with same shape as `input`:
+///
+/// ```python
+/// input = [[b'ten', b'eleven', b'twelve'],
+///          [b'thirteen', b'fourteen', b'fifteen'],
+///          [b'sixteen', b'seventeen', b'eighteen']]
+/// position = [[1, 2, 3],
+///             [1, 2, 3],
+///             [1, 2, 3]]
+/// length =   [[2, 3, 4],
+///             [4, 3, 2],
+///             [5, 5, 5]]
+///
+/// output = [[b'en', b'eve', b'lve'],
+///           [b'hirt', b'urt', b'te'],
+///           [b'ixtee', b'vente', b'hteen']]
+/// ```
+///
+/// Broadcasting `pos` and `len` onto `input`:
+///
+/// ```
+/// input = [[b'ten', b'eleven', b'twelve'],
+///          [b'thirteen', b'fourteen', b'fifteen'],
+///          [b'sixteen', b'seventeen', b'eighteen'],
+///          [b'nineteen', b'twenty', b'twentyone']]
+/// position = [1, 2, 3]
+/// length =   [1, 2, 3]
+///
+/// output = [[b'e', b'ev', b'lve'],
+///           [b'h', b'ur', b'tee'],
+///           [b'i', b've', b'hte'],
+///           [b'i', b'en', b'nty']]
+/// ```
+///
+/// Broadcasting `input` onto `pos` and `len`:
+///
+/// ```
+/// input = b'thirteen'
+/// position = [1, 5, 7]
+/// length =   [3, 2, 1]
+///
+/// output = [b'hir', b'ee', b'n']
+/// ```
+///
+/// - Parameters:
+///     - input: Tensor of strings
+///     - pos: Scalar defining the position of first character in each substring
+///     - len: Scalar defining the number of characters to include in each substring
+///
+/// - Attr unit: The unit that is used to create the substring.  One of: `"BYTE"` (for
+///     defining position and length by bytes) or `"UTF8_CHAR"` (for the UTF-8
+///     encoded Unicode code points).  The default is `"BYTE"`. Results are undefined if
+///     `unit=UTF8_CHAR` and the `input` strings do not contain structurally valid
+///     UTF-8.
+///
+/// - Output output: Tensor of substrings
+@inlinable @inline(__always)
+public static func substr<T: BinaryInteger & TensorFlowScalar>(
+    _ input: StringTensor,
+    pos: Tensor<T>,
+    len: Tensor<T>,
+    unit: Unit = .byte
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("Substr", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("unit", unit.cName)
+    op.addInput(input)
+    op.addInput(pos)
+    op.addInput(len)
+    return op.execute(Int(1))
+}
+
+/// Computes the sum of elements across dimensions of a tensor.
+///
+/// Reduces `input` along the dimensions given in `axis`. Unless
+/// `keep_dims` is true, the rank of the tensor is reduced by 1 for each entry in
+/// `axis`. If `keep_dims` is true, the reduced dimensions are
+/// retained with length 1.
+///
+/// - Parameters:
+///     - input: The tensor to reduce.
+///     - reduction_indices: The dimensions to reduce. Must be in the range
+///         `[-rank(input), rank(input))`.
+///
+/// - Attr keep_dims: If true, retain reduced dimensions with length 1.
+///
+/// - Output output: The reduced tensor.
+@inlinable @inline(__always)
+public static func sum<
+    T: Numeric & TensorFlowScalar,
+    Tidx: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    reductionIndices: Tensor<Tidx>,
+    keepDims: Bool = false
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Sum", nOutputs)
+    op.updateAttribute("keep_dims", keepDims)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(reductionIndices)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func summaryWriter(
+    sharedName: String,
+    container: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("SummaryWriter", nOutputs)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("container", container)
+    return op.execute(Int(1))
+}
+
+/// Computes the singular value decompositions of one or more matrices.
+///
+/// Computes the SVD of each inner matrix in `input` such that
+/// `input[..., :, :] = u[..., :, :] * diag(s[..., :, :]) * transpose(v[..., :, :])`
+///
+/// ```python
+/// # a is a tensor containing a batch of matrices.
+/// # s is a tensor of singular values for each matrix.
+/// # u is the tensor containing of left singular vectors for each matrix.
+/// # v is the tensor containing of right singular vectors for each matrix.
+/// s, u, v = svd(a)
+/// s, _, _ = svd(a, compute_uv=False)
+/// ```
+///
+/// - Parameter input: A tensor of shape `[..., M, N]` whose inner-most 2 dimensions
+///     form matrices of size `[M, N]`. Let `P` be the minimum of `M` and `N`.
+///
+/// - Attrs:
+///     - compute_uv: If true, left and right singular vectors will be
+///         computed and returned in `u` and `v`, respectively.
+///         If false, `u` and `v` are not set and should never referenced.
+///     - full_matrices: If true, compute full-sized `u` and `v`. If false
+///         (the default), compute only the leading `P` singular vectors.
+///         Ignored if `compute_uv` is `False`.
+///
+/// - Outputs:
+///     - s: Singular values. Shape is `[..., P]`.
+///     - u: Left singular vectors. If `full_matrices` is `False` then shape is
+///         `[..., M, P]`; if `full_matrices` is `True` then shape is
+///         `[..., M, M]`. Undefined if `compute_uv` is `False`.
+///     - v: Left singular vectors. If `full_matrices` is `False` then shape is
+///         `[..., N, P]`. If `full_matrices` is `True` then shape is `[..., N, N]`.
+///         Undefined if `compute_uv` is false.
+@inlinable @inline(__always)
+public static func svd<T: FloatingPoint & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    computeUv: Bool = true,
+    fullMatrices: Bool = false
+) -> (s: Tensor<T>, u: Tensor<T>, v: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("Svd", nOutputs)
+    op.updateAttribute("compute_uv", computeUv)
+    op.updateAttribute("full_matrices", fullMatrices)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Forwards `data` to the output port determined by `pred`.
+///
+/// If `pred` is true, the `data` input is forwarded to `output_true`. Otherwise,
+/// the data goes to `output_false`.
+///
+/// See also `RefSwitch` and `Merge`.
+///
+/// - Parameters:
+///     - data: The tensor to be forwarded to the appropriate output.
+///     - pred: A scalar that specifies which output port will receive data.
+///
+/// - Outputs:
+///     - output_false: If `pred` is false, data will be forwarded to this output.
+///     - output_true: If `pred` is true, data will be forwarded to this output.
+@inlinable @inline(__always)
+public static func switch_<T: TensorFlowScalar>(
+    data: Tensor<T>,
+    pred: Tensor<Bool>
+) -> (outputFalse: Tensor<T>, outputTrue: Tensor<T>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("Switch", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(pred)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Computes the gradient function for function f via backpropagation.
+///
+/// - Parameter input: a list of input tensors of size N + M;
+///
+/// - Attrs:
+///     - Tin: the type list for the input list.
+///     - Tout: the type list for the input list.
+///     - f: The function we want to compute the gradient for.
+///
+///         The function 'f' must be a numerical function which takes N inputs and
+///         produces M outputs. Its gradient function 'g', which is computed by
+///         this SymbolicGradient op is a function taking N + M inputs and
+///         produces N outputs.
+///
+///         I.e. if we have
+///            (y1, y2, ..., y_M) = f(x1, x2, ..., x_N),
+///         then, g is
+///            (dL/dx1, dL/dx2, ..., dL/dx_N) = g(x1, x2, ..., x_N,
+///                                              dL/dy1, dL/dy2, ..., dL/dy_M),
+///
+///         where L is a scalar-value function of (x1, x2, ..., xN) (e.g., the
+///         loss function). dL/dx_i is the partial derivative of L with respect
+///         to x_i.
+///
+///         (Needs some math expert to say the comment above better.)
+///
+/// - Output output: a list of output tensors of size N;
+@inlinable @inline(__always)
+public static func symbolicGradient<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    FIn: TensorGroup,
+    FOut: TensorGroup
+>(
+    _ input: Tin,
+    f: (FIn) -> FOut
+) -> Tout {
+  let nOutputs = Int(Tout._typeList.count)
+    let op = makeOp("SymbolicGradient", nOutputs)
+    op.updateAttribute("Tin", input._typeList)
+    op.updateAttribute("Tout", Tout._typeList)
+    op.updateAttribute("f", f)
+    op.addInputList(input)
+    return op.execute(Int(Tout._typeList.count))
+}
+
+/// Creates a dataset that emits the records from one or more TFRecord files.
+///
+/// - Parameters:
+///     - filenames: A scalar or vector containing the name(s) of the file(s) to be
+///         read.
+///     - compression_type: A scalar containing either (i) the empty string (no
+///         compression), (ii) "ZLIB", or (iii) "GZIP".
+///     - buffer_size: A scalar representing the number of bytes to buffer. A value of
+///         0 means no buffering will be performed.
+@inlinable @inline(__always)
+public static func tFRecordDataset(
+    filenames: StringTensor,
+    compressionType: StringTensor,
+    bufferSize: Tensor<Int64>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TFRecordDataset", nOutputs)
+    op.addInput(filenames)
+    op.addInput(compressionType)
+    op.addInput(bufferSize)
+    return op.execute(Int(1))
+}
+
+/// A Reader that outputs the records from a TensorFlow Records file.
+///
+/// - Attrs:
+///     - container: If non-empty, this reader is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this reader is named in the given bucket
+///         with this shared_name. Otherwise, the node name is used instead.
+///
+/// - Output reader_handle: The handle to reference the Reader.
+@inlinable @inline(__always)
+public static func tFRecordReaderV2(
+    container: String,
+    sharedName: String,
+    compressionType: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TFRecordReaderV2", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("compression_type", compressionType)
+    return op.execute(Int(1))
+}
+
+/// CompilationResultProto indicating the status of the TPU compilation.
+@inlinable @inline(__always)
+public static func tPUCompilationResult(
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("TPUCompilationResult", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+/// An op enabling differentiation of TPU Embeddings.
+///
+/// This op simply returns its first input, which is assumed to have been sliced
+/// from the Tensors returned by TPUEmbeddingDequeueActivations. The presence of
+/// this op, and its first argument being a trainable Variable, enables automatic
+/// differentiation of graphs containing embeddings via the TPU Embedding Python
+/// libraries.
+///
+/// - Parameters:
+///     - embedding_variable: A trainable variable, enabling optimizers to find this op.
+///     - sliced_activations: The embedding activations Tensor to return.
+///
+/// - Attrs:
+///     - table_id: The id of the table in the embedding layer configuration from which
+///         these activations were computed.
+///     - lookup_id: Identifier of the set of embedding indices which produced these
+///         activations.
+@inlinable @inline(__always)
+public static func tPUEmbeddingActivations(
+    embeddingVariable: Tensor<Float>,
+    slicedActivations: Tensor<Float>,
+    tableId: Int64,
+    lookupId: Int64
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("TPUEmbeddingActivations", nOutputs)
+    op.updateAttribute("table_id", tableId)
+    op.updateAttribute("lookup_id", lookupId)
+    op.addInput(embeddingVariable)
+    op.addInput(slicedActivations)
+    return op.execute(Int(1))
+}
+
+/// A TPU core selector Op.
+///
+/// This Op produces a set of TPU cores (for warm-up) or a single TPU core
+/// (for regular inference) to execute the TPU program on. The output is
+/// consumed by TPUPartitionedCall.
+///
+/// - Output device_ordinals: A vector 1 or more TPU cores.
+@inlinable @inline(__always)
+public static func tPUOrdinalSelector(
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("TPUOrdinalSelector", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+/// Calls a function placed on a specified TPU device.
+///
+/// - Parameters:
+///     - args: The arguments to the function.
+///     - device_ordinal: The TPU device ordinal to run the function on.
+///
+/// - Attrs:
+///     - Tin: The types of the arguments to the function.
+///     - Tout: The types of the outputs of the function.
+///     - f: The function to call.
+///
+/// - Output output: The output of the function call.
+@inlinable @inline(__always)
+public static func tPUPartitionedCall<
+    Tin: TensorArrayProtocol,
+    Tout: TensorGroup,
+    FIn: TensorGroup,
+    FOut: TensorGroup
+>(
+    args: Tin,
+    deviceOrdinal: Tensor<Int32>,
+    f: (FIn) -> FOut
+) -> Tout {
+  let nOutputs = Int(Tout._typeList.count)
+    let op = makeOp("TPUPartitionedCall", nOutputs)
+    op.updateAttribute("Tin", args._typeList)
+    op.updateAttribute("Tout", Tout._typeList)
+    op.updateAttribute("f", f)
+    op.addInputList(args)
+    op.addInput(deviceOrdinal)
+    return op.execute(Int(Tout._typeList.count))
+}
+
+/// Runs replicated computations on a distributed TPU system.
+///
+/// - Parameters:
+///     - inputs: the inputs to 'computation', flattened, in replica-major order.
+///     - broadcast_inputs: additional arguments to broadcast to all replicas. The
+///         broadcast inputs are appended to the per-replica inputs when calling
+///         computation.
+///     - guaranteed_constants: arguments which have been guaranteed to not
+///         change their values during the session lifetime. These contain tensors marked as
+///         constant using the GuaranteeConstOp.
+///
+/// - Attrs:
+///     - computation: a function containing the computation to run.
+///     - num_replicas: the number of replicas of the computation to run.
+///     - num_cores_per_replica: the number of logical cores in each replica.
+///     - topology: A serialized tensorflow.tpu.TopologyProto that describes the TPU
+///         topology.
+///     - use_tpu: a bool indicating if this computation will run on TPU or CPU/GPU.
+///         Currently, only supports a default placement (computation is placed on GPU
+///         if one is available, and on CPU if not).
+///     - device_assignment: a flattened array with shape
+///         [replica, num_cores_per_replica, mesh_dimension] that maps the coordinates
+///         of logical cores in each replica of a computation to physical coordinates in
+///         the TPU topology.
+///     - Tinputs: the types of the arguments to 'computation'.
+///     - Tbroadcast_inputs: the types of the additional arguments to broadcast to all
+///         replicas.
+///     - Tguaranteed_constants: the types of the arguments to 'guaranteed_constants'.
+///     - output_types: the types of the outputs of 'computation'.
+///
+/// - Output outputs: the outputs of 'computation'.
+@inlinable @inline(__always)
+public static func tPUReplicate<
+    ComputationIn: TensorGroup,
+    ComputationOut: TensorGroup,
+    Tinputs: TensorArrayProtocol,
+    TbroadcastInputs: TensorArrayProtocol,
+    TguaranteedConstants: TensorArrayProtocol,
+    OutputTypes: TensorGroup
+>(
+    inputs: Tinputs,
+    broadcastInputs: TbroadcastInputs,
+    variables: [ResourceHandle],
+    guaranteedConstants: TguaranteedConstants,
+    computation: (ComputationIn) -> ComputationOut,
+    numReplicas: Int64,
+    numCoresPerReplica: Int64 = 1,
+    topology: String,
+    useTpu: Bool = true,
+    deviceAssignment: [Int32],
+    hostComputeCore: [String],
+    paddingMap: [String],
+    stepMarkerLocation: String = "STEP_MARK_AT_ENTRY"
+) -> OutputTypes {
+  let nOutputs = Int(OutputTypes._typeList.count)
+    let op = makeOp("TPUReplicate", nOutputs)
+    op.updateAttribute("computation", computation)
+    op.updateAttribute("num_replicas", numReplicas)
+    op.updateAttribute("num_cores_per_replica", numCoresPerReplica)
+    op.updateAttribute("topology", topology)
+    op.updateAttribute("use_tpu", useTpu)
+    op.updateAttribute("device_assignment", deviceAssignment)
+    op.updateAttribute("host_compute_core", hostComputeCore)
+    op.updateAttribute("Tinputs", inputs._typeList)
+    op.updateAttribute("Tbroadcast_inputs", broadcastInputs._typeList)
+    op.updateAttribute("NumVariables", variables.count)
+    op.updateAttribute("Tguaranteed_constants", guaranteedConstants._typeList)
+    op.updateAttribute("output_types", OutputTypes._typeList)
+    op.updateAttribute("padding_map", paddingMap)
+    op.updateAttribute("step_marker_location", stepMarkerLocation)
+    op.addInputList(inputs)
+    op.addInputList(broadcastInputs)
+    op.addInputList(variables)
+    op.addInputList(guaranteedConstants)
+    return op.execute(Int(OutputTypes._typeList.count))
+}
+
+/// Metadata indicaitng how the TPU computation should be replicated.
+///
+/// - Attrs:
+///     - num_replicas: Number of replicas of the computation
+///     - num_cores_per_replica: Number of cores per replica. Used for model parallelism.
+///     - topology: TopologyProto indicating the topology of the TPU pod slice.
+///     - use_tpu: Whether to place the computation on the TPU.
+///     - device_assignment: The assignment of devices for the computation.
+///     - computation_shape: DEPRECATED. Use num_cores_per_replica instead.
+@inlinable @inline(__always)
+public static func tPUReplicateMetadata(
+    numReplicas: Int64,
+    numCoresPerReplica: Int64 = 1,
+    topology: String,
+    useTpu: Bool = true,
+    deviceAssignment: [Int32],
+    computationShape: [Int32],
+    hostComputeCore: [String],
+    paddingMap: [String],
+    stepMarkerLocation: String = "STEP_MARK_AT_ENTRY"
+) {
+  let nOutputs = 0
+    let op = makeOp("TPUReplicateMetadata", nOutputs)
+    op.updateAttribute("num_replicas", numReplicas)
+    op.updateAttribute("num_cores_per_replica", numCoresPerReplica)
+    op.updateAttribute("topology", topology)
+    op.updateAttribute("use_tpu", useTpu)
+    op.updateAttribute("device_assignment", deviceAssignment)
+    op.updateAttribute("computation_shape", computationShape)
+    op.updateAttribute("host_compute_core", hostComputeCore)
+    op.updateAttribute("padding_map", paddingMap)
+    op.updateAttribute("step_marker_location", stepMarkerLocation)
+    op.execute()
+}
+
+/// Connects N inputs to an N-way replicated TPU computation.
+@inlinable @inline(__always)
+public static func tPUReplicatedInput<T: TensorFlowScalar>(
+    inputs: [Tensor<T>]
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("TPUReplicatedInput", nOutputs)
+    op.updateAttribute("N", inputs.count)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInputList(inputs)
+    return op.execute(Int(1))
+}
+
+/// Connects outputs of an N-way replicated computation to N outputs.
+@inlinable @inline(__always)
+public static func tPUReplicatedOutput<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    numReplicas: Int64
+) -> [Tensor<T>] {
+  let nOutputs = Int(numReplicas)
+    let op = makeOp("TPUReplicatedOutput", nOutputs)
+    op.updateAttribute("num_replicas", numReplicas)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(numReplicas))
+}
+
+/// Creates a dataset that contains `count` elements from the `input_dataset`.
+///
+/// - Parameter count: A scalar representing the number of elements from the `input_dataset`
+///     that should be taken. A value of `-1` indicates that all of `input_dataset`
+///     is taken.
+@inlinable @inline(__always)
+public static func takeDataset(
+    inputDataset: VariantHandle,
+    count: Tensor<Int64>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TakeDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(count)
+    return op.execute(Int(1))
+}
+
+/// Read `SparseTensors` from a `SparseTensorsMap` and concatenate them.
+///
+/// The input `sparse_handles` must be an `int64` matrix of shape `[N, 1]` where
+/// `N` is the minibatch size and the rows correspond to the output handles of
+/// `AddSparseToTensorsMap` or `AddManySparseToTensorsMap`.  The ranks of the
+/// original `SparseTensor` objects that went into the given input ops must all
+/// match.  When the final `SparseTensor` is created, it has rank one
+/// higher than the ranks of the incoming `SparseTensor` objects
+/// (they have been concatenated along a new row dimension on the left).
+///
+/// The output `SparseTensor` object's shape values for all dimensions but the
+/// first are the max across the input `SparseTensor` objects' shape values
+/// for the corresponding dimensions.  Its first shape value is `N`, the minibatch
+/// size.
+///
+/// The input `SparseTensor` objects' indices are assumed ordered in
+/// standard lexicographic order.  If this is not the case, after this
+/// step run `SparseReorder` to restore index ordering.
+///
+/// For example, if the handles represent an input, which is a `[2, 3]` matrix
+/// representing two original `SparseTensor` objects:
+///
+/// ```
+///     index = [ 0]
+///             [10]
+///             [20]
+///     values = [1, 2, 3]
+///     shape = [50]
+/// ```
+///
+/// and
+///
+/// ```
+///     index = [ 2]
+///             [10]
+///     values = [4, 5]
+///     shape = [30]
+/// ```
+///
+/// then the final `SparseTensor` will be:
+///
+/// ```
+///     index = [0  0]
+///             [0 10]
+///             [0 20]
+///             [1  2]
+///             [1 10]
+///     values = [1, 2, 3, 4, 5]
+///     shape = [2 50]
+/// ```
+///
+/// - Parameter sparse_handles: 1-D, The `N` serialized `SparseTensor` objects.
+///     Shape: `[N]`.
+///
+/// - Attrs:
+///     - dtype: The `dtype` of the `SparseTensor` objects stored in the
+///         `SparseTensorsMap`.
+///     - container: The container name for the `SparseTensorsMap` read by this op.
+///     - shared_name: The shared name for the `SparseTensorsMap` read by this op.
+///         It should not be blank; rather the `shared_name` or unique Operation name
+///         of the Op that created the original `SparseTensorsMap` should be used.
+///
+/// - Outputs:
+///     - sparse_indices: 2-D.  The `indices` of the minibatch `SparseTensor`.
+///     - sparse_values: 1-D.  The `values` of the minibatch `SparseTensor`.
+///     - sparse_shape: 1-D.  The `shape` of the minibatch `SparseTensor`.
+@inlinable @inline(__always)
+public static func takeManySparseFromTensorsMap<Dtype: TensorFlowScalar>(
+    sparseHandles: Tensor<Int64>,
+    container: String,
+    sharedName: String
+) -> (sparseIndices: Tensor<Int64>, sparseValues: Tensor<Dtype>, sparseShape: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("TakeManySparseFromTensorsMap", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.addInput(sparseHandles)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Computes tan of x element-wise.
+@inlinable @inline(__always)
+public static func tan<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Tan", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes hyperbolic tangent of `x` element-wise.
+@inlinable @inline(__always)
+public static func tanh<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Tanh", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Computes the gradient for the tanh of `x` wrt its input.
+///
+/// Specifically, `grad = dy * (1 - y*y)`, where `y = tanh(x)`, and `dy`
+/// is the corresponding input gradient.
+@inlinable @inline(__always)
+public static func tanhGrad<T: FloatingPoint & TensorFlowScalar>(
+    _ y: Tensor<T>,
+    dy: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("TanhGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(y)
+    op.addInput(dy)
+    return op.execute(Int(1))
+}
+
+/// Deprecated. Use TensorArrayCloseV3
+@inlinable @inline(__always)
+public static func tensorArrayCloseV2(
+    handle: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("TensorArrayCloseV2", nOutputs)
+    op.addInput(handle)
+    op.execute()
+}
+
+/// Delete the TensorArray from its resource container.
+///
+/// This enables the user to close and release the resource in the middle
+/// of a step/run.
+///
+/// - Parameter handle: The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
+@inlinable @inline(__always)
+public static func tensorArrayCloseV3(
+    handle: ResourceHandle
+) {
+  let nOutputs = 0
+    let op = makeOp("TensorArrayCloseV3", nOutputs)
+    op.addInput(handle)
+    op.execute()
+}
+
+/// Deprecated. Use TensorArrayConcatV3
+@inlinable @inline(__always)
+public static func tensorArrayConcatV2<Dtype: TensorFlowScalar>(
+    handle: StringTensor,
+    flowIn: Tensor<Float>,
+    elementShapeExcept0: TensorShape?
+) -> (value: Tensor<Dtype>, lengths: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TensorArrayConcatV2", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("element_shape_except0", elementShapeExcept0)
+    op.addInput(handle)
+    op.addInput(flowIn)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Concat the elements from the TensorArray into value `value`.
+///
+/// Takes `T` elements of shapes
+///
+///   ```
+///   (n0 x d0 x d1 x ...), (n1 x d0 x d1 x ...), ..., (n(T-1) x d0 x d1 x ...)
+///   ```
+///
+/// and concatenates them into a Tensor of shape:
+///
+///   ```(n0 + n1 + ... + n(T-1) x d0 x d1 x ...)```
+///
+/// All elements must have the same shape (excepting the first dimension).
+///
+/// - Parameters:
+///     - handle: The handle to a TensorArray.
+///     - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Attrs:
+///     - dtype: The type of the elem that is returned.
+///     - element_shape_except0: The expected shape of an element, if known,
+///         excluding the first dimension. Used to validate the shapes of
+///         TensorArray elements. If this shape is not fully specified, concatenating
+///         zero-size TensorArrays is an error.
+///
+/// - Outputs:
+///     - value: All of the elements in the TensorArray, concatenated along the first
+///         axis.
+///     - lengths: A vector of the row sizes of the original T elements in the
+///         value output.  In the example above, this would be the values:
+///         `(n1, n2, ..., n(T-1))`.
+@inlinable @inline(__always)
+public static func tensorArrayConcatV3<Dtype: TensorFlowScalar>(
+    handle: ResourceHandle,
+    flowIn: Tensor<Float>,
+    elementShapeExcept0: TensorShape?
+) -> (value: Tensor<Dtype>, lengths: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TensorArrayConcatV3", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("element_shape_except0", elementShapeExcept0)
+    op.addInput(handle)
+    op.addInput(flowIn)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Deprecated. Use TensorArrayGatherV3
+@inlinable @inline(__always)
+public static func tensorArrayGatherV2<Dtype: TensorFlowScalar>(
+    handle: StringTensor,
+    indices: Tensor<Int32>,
+    flowIn: Tensor<Float>,
+    elementShape: TensorShape?
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArrayGatherV2", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("element_shape", elementShape)
+    op.addInput(handle)
+    op.addInput(indices)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Gather specific elements from the TensorArray into output `value`.
+///
+/// All elements selected by `indices` must have the same shape.
+///
+/// - Parameters:
+///     - handle: The handle to a TensorArray.
+///     - indices: The locations in the TensorArray from which to read tensor elements.
+///     - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Attrs:
+///     - dtype: The type of the elem that is returned.
+///     - element_shape: The expected shape of an element, if known. Used to
+///         validate the shapes of TensorArray elements. If this shape is not
+///         fully specified, gathering zero-size TensorArrays is an error.
+///
+/// - Output value: All of the elements in the TensorArray, concatenated along a new
+///     axis (the new dimension 0).
+@inlinable @inline(__always)
+public static func tensorArrayGatherV3<Dtype: TensorFlowScalar>(
+    handle: ResourceHandle,
+    indices: Tensor<Int32>,
+    flowIn: Tensor<Float>,
+    elementShape: TensorShape?
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArrayGatherV3", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("element_shape", elementShape)
+    op.addInput(handle)
+    op.addInput(indices)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Deprecated. Use TensorArrayGradV3
+@inlinable @inline(__always)
+public static func tensorArrayGradV2(
+    handle: StringTensor,
+    flowIn: Tensor<Float>,
+    source: String
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArrayGradV2", nOutputs)
+    op.updateAttribute("source", source)
+    op.addInput(handle)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Creates a TensorArray for storing the gradients of values in the given handle.
+///
+/// If the given TensorArray gradient already exists, returns a reference to it.
+///
+/// Locks the size of the original TensorArray by disabling its dynamic size flag.
+///
+/// **A note about the input flow_in:**
+///
+/// The handle flow_in forces the execution of the gradient lookup to occur
+/// only after certain other operations have occurred.  For example, when
+/// the forward TensorArray is dynamically sized, writes to this TensorArray
+/// may resize the object.  The gradient TensorArray is statically sized based
+/// on the size of the forward TensorArray when this operation executes.
+/// Furthermore, the size of the forward TensorArray is frozen by this call.
+/// As a result, the flow is used to ensure that the call to generate the gradient
+/// TensorArray only happens after all writes are executed.
+///
+/// In the case of dynamically sized TensorArrays, gradient computation should
+/// only be performed on read operations that have themselves been chained via
+/// flow to occur only after all writes have executed. That way the final size
+/// of the forward TensorArray is known when this operation is called.
+///
+/// **A note about the source attribute:**
+///
+/// TensorArray gradient calls use an accumulator TensorArray object.  If
+/// multiple gradients are calculated and run in the same session, the multiple
+/// gradient nodes may accidentally flow through the same accumulator TensorArray.
+/// This double counts and generally breaks the TensorArray gradient flow.
+///
+/// The solution is to identify which gradient call this particular
+/// TensorArray gradient is being called in.  This is performed by identifying
+/// a unique string (e.g. "gradients", "gradients_1", ...) from the input
+/// gradient Tensor's name.  This string is used as a suffix when creating
+/// the TensorArray gradient object here (the attribute `source`).
+///
+/// The attribute `source` is added as a suffix to the forward TensorArray's
+/// name when performing the creation / lookup, so that each separate gradient
+/// calculation gets its own TensorArray accumulator.
+///
+/// - Parameters:
+///     - handle: The handle to the forward TensorArray.
+///     - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Attr source: The gradient source string, used to decide which gradient TensorArray
+///     to return.
+@inlinable @inline(__always)
+public static func tensorArrayGradV3(
+    handle: ResourceHandle,
+    flowIn: Tensor<Float>,
+    source: String
+) -> (gradHandle: ResourceHandle, flowOut: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TensorArrayGradV3", nOutputs)
+    op.updateAttribute("source", source)
+    op.addInput(handle)
+    op.addInput(flowIn)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Creates a TensorArray for storing multiple gradients of values in the given handle.
+///
+/// Similar to TensorArrayGradV3. However it creates an accumulator with an
+/// expanded shape compared to the input TensorArray whose gradient is being
+/// computed. This enables multiple gradients for the same TensorArray to be
+/// calculated using the same accumulator.
+///
+/// - Parameters:
+///     - handle: The handle to the forward TensorArray.
+///     - flow_in: A float scalar that enforces proper chaining of operations.
+///     - shape_to_prepend: An int32 vector representing a shape. Elements in the gradient accumulator will
+///         have shape which is this shape_to_prepend value concatenated with shape of the
+///         elements in the TensorArray corresponding to the input handle.
+///
+/// - Attr source: The gradient source string, used to decide which gradient TensorArray
+///     to return.
+@inlinable @inline(__always)
+public static func tensorArrayGradWithShape(
+    handle: ResourceHandle,
+    flowIn: Tensor<Float>,
+    shapeToPrepend: Tensor<Int32>,
+    source: String
+) -> (gradHandle: ResourceHandle, flowOut: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TensorArrayGradWithShape", nOutputs)
+    op.updateAttribute("source", source)
+    op.addInput(handle)
+    op.addInput(flowIn)
+    op.addInput(shapeToPrepend)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Deprecated. Use TensorArrayReadV3
+@inlinable @inline(__always)
+public static func tensorArrayReadV2<Dtype: TensorFlowScalar>(
+    handle: StringTensor,
+    index: Tensor<Int32>,
+    flowIn: Tensor<Float>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArrayReadV2", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(handle)
+    op.addInput(index)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Read an element from the TensorArray into output `value`.
+///
+/// - Parameters:
+///     - handle: The handle to a TensorArray.
+///     - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Attr dtype: The type of the elem that is returned.
+///
+/// - Output value: The tensor that is read from the TensorArray.
+@inlinable @inline(__always)
+public static func tensorArrayReadV3<Dtype: TensorFlowScalar>(
+    handle: ResourceHandle,
+    index: Tensor<Int32>,
+    flowIn: Tensor<Float>
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArrayReadV3", nOutputs)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.addInput(handle)
+    op.addInput(index)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Deprecated. Use TensorArrayScatterV3
+@inlinable @inline(__always)
+public static func tensorArrayScatterV2<T: TensorFlowScalar>(
+    handle: StringTensor,
+    indices: Tensor<Int32>,
+    value: Tensor<T>,
+    flowIn: Tensor<Float>
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArrayScatterV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(handle)
+    op.addInput(indices)
+    op.addInput(value)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Scatter the data from the input value into specific TensorArray elements.
+///
+/// `indices` must be a vector, its length must match the first dim of `value`.
+///
+/// - Parameters:
+///     - handle: The handle to a TensorArray.
+///     - indices: The locations at which to write the tensor elements.
+///     - value: The concatenated tensor to write to the TensorArray.
+///     - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Output flow_out: A float scalar that enforces proper chaining of operations.
+@inlinable @inline(__always)
+public static func tensorArrayScatterV3<T: TensorFlowScalar>(
+    handle: ResourceHandle,
+    indices: Tensor<Int32>,
+    value: Tensor<T>,
+    flowIn: Tensor<Float>
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArrayScatterV3", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(handle)
+    op.addInput(indices)
+    op.addInput(value)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Deprecated. Use TensorArraySizeV3
+@inlinable @inline(__always)
+public static func tensorArraySizeV2(
+    handle: StringTensor,
+    flowIn: Tensor<Float>
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArraySizeV2", nOutputs)
+    op.addInput(handle)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Get the current size of the TensorArray.
+///
+/// - Parameters:
+///     - handle: The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
+///     - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Output size: The current size of the TensorArray.
+@inlinable @inline(__always)
+public static func tensorArraySizeV3(
+    handle: ResourceHandle,
+    flowIn: Tensor<Float>
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArraySizeV3", nOutputs)
+    op.addInput(handle)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Deprecated. Use TensorArraySplitV3
+@inlinable @inline(__always)
+public static func tensorArraySplitV2<T: TensorFlowScalar>(
+    handle: StringTensor,
+    value: Tensor<T>,
+    lengths: Tensor<Int64>,
+    flowIn: Tensor<Float>
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArraySplitV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(handle)
+    op.addInput(value)
+    op.addInput(lengths)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Split the data from the input value into TensorArray elements.
+///
+/// Assuming that `lengths` takes on values
+///
+///   ```(n0, n1, ..., n(T-1))```
+///
+/// and that `value` has shape
+///
+///   ```(n0 + n1 + ... + n(T-1) x d0 x d1 x ...)```,
+///
+/// this splits values into a TensorArray with T tensors.
+///
+/// TensorArray index t will be the subtensor of values with starting position
+///
+///   ```(n0 + n1 + ... + n(t-1), 0, 0, ...)```
+///
+/// and having size
+///
+///   ```nt x d0 x d1 x ...```
+///
+/// - Parameters:
+///     - handle: The handle to a TensorArray.
+///     - value: The concatenated tensor to write to the TensorArray.
+///     - lengths: The vector of lengths, how to split the rows of value into the
+///         TensorArray.
+///     - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Output flow_out: A float scalar that enforces proper chaining of operations.
+@inlinable @inline(__always)
+public static func tensorArraySplitV3<T: TensorFlowScalar>(
+    handle: ResourceHandle,
+    value: Tensor<T>,
+    lengths: Tensor<Int64>,
+    flowIn: Tensor<Float>
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArraySplitV3", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(handle)
+    op.addInput(value)
+    op.addInput(lengths)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Deprecated. Use TensorArrayV3
+@inlinable @inline(__always)
+public static func tensorArrayV2(
+    size: Tensor<Int32>,
+    dtype: TensorDataType,
+    elementShape: TensorShape?,
+    dynamicSize: Bool = false,
+    clearAfterRead: Bool = true,
+    tensorArrayName: String
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArrayV2", nOutputs)
+    op.updateAttribute("dtype", dtype)
+    op.updateAttribute("element_shape", elementShape)
+    op.updateAttribute("dynamic_size", dynamicSize)
+    op.updateAttribute("clear_after_read", clearAfterRead)
+    op.updateAttribute("tensor_array_name", tensorArrayName)
+    op.addInput(size)
+    return op.execute(Int(1))
+}
+
+/// An array of Tensors of given size.
+///
+/// Write data via Write and read via Read or Pack.
+///
+/// - Parameter size: The size of the array.
+///
+/// - Attrs:
+///     - dtype: The type of the elements on the tensor_array.
+///     - element_shape: The expected shape of an element, if known. Used to
+///         validate the shapes of TensorArray elements. If this shape is not
+///         fully specified, gathering zero-size TensorArrays is an error.
+///     - dynamic_size: A boolean that determines whether writes to the TensorArray
+///         are allowed to grow the size.  By default, this is not allowed.
+///     - clear_after_read: If true (default), Tensors in the TensorArray are cleared
+///         after being read.  This disables multiple read semantics but allows early
+///         release of memory.
+///     - identical_element_shapes: If true (default is false), then all
+///         elements in the TensorArray will be expected to have have identical shapes.
+///         This allows certain behaviors, like dynamically checking for
+///         consistent shapes on write, and being able to fill in properly
+///         shaped zero tensors on stack -- even if the element_shape attribute
+///         is not fully defined.
+///     - tensor_array_name: Overrides the name used for the temporary tensor_array
+///         resource. Default value is the name of the 'TensorArray' op (which
+///         is guaranteed unique).
+///
+/// - Outputs:
+///     - handle: The handle to the TensorArray.
+///     - flow: A scalar used to control gradient flow.
+@inlinable @inline(__always)
+public static func tensorArrayV3(
+    size: Tensor<Int32>,
+    dtype: TensorDataType,
+    elementShape: TensorShape?,
+    dynamicSize: Bool = false,
+    clearAfterRead: Bool = true,
+    identicalElementShapes: Bool = false,
+    tensorArrayName: String
+) -> (handle: ResourceHandle, flow: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TensorArrayV3", nOutputs)
+    op.updateAttribute("dtype", dtype)
+    op.updateAttribute("element_shape", elementShape)
+    op.updateAttribute("dynamic_size", dynamicSize)
+    op.updateAttribute("clear_after_read", clearAfterRead)
+    op.updateAttribute("identical_element_shapes", identicalElementShapes)
+    op.updateAttribute("tensor_array_name", tensorArrayName)
+    op.addInput(size)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Deprecated. Use TensorArrayGradV3
+@inlinable @inline(__always)
+public static func tensorArrayWriteV2<T: TensorFlowScalar>(
+    handle: StringTensor,
+    index: Tensor<Int32>,
+    value: Tensor<T>,
+    flowIn: Tensor<Float>
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArrayWriteV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(handle)
+    op.addInput(index)
+    op.addInput(value)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Push an element onto the tensor_array.
+///
+/// - Parameters:
+///     - handle: The handle to a TensorArray.
+///     - index: The position to write to inside the TensorArray.
+///     - value: The tensor to write to the TensorArray.
+///     - flow_in: A float scalar that enforces proper chaining of operations.
+///
+/// - Output flow_out: A float scalar that enforces proper chaining of operations.
+@inlinable @inline(__always)
+public static func tensorArrayWriteV3<T: TensorFlowScalar>(
+    handle: ResourceHandle,
+    index: Tensor<Int32>,
+    value: Tensor<T>,
+    flowIn: Tensor<Float>
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorArrayWriteV3", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(handle)
+    op.addInput(index)
+    op.addInput(value)
+    op.addInput(flowIn)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that emits `components` as a tuple of tensors once.
+@inlinable @inline(__always)
+public static func tensorDataset<ToutputTypes: TensorArrayProtocol>(
+    components: ToutputTypes,
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorDataset", nOutputs)
+    op.updateAttribute("Toutput_types", components._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInputList(components)
+    return op.execute(Int(1))
+}
+
+/// Creates a tree resource and returns a handle to it.
+///
+/// - Parameters:
+///     - tree_handle: Handle to the tree resource to be created.
+///     - tree_config: Serialized proto string of the boosted_trees.Tree.
+@inlinable @inline(__always)
+public static func tensorForestCreateTreeVariable(
+    treeHandle: ResourceHandle,
+    treeConfig: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("TensorForestCreateTreeVariable", nOutputs)
+    op.addInput(treeHandle)
+    op.addInput(treeConfig)
+    op.execute()
+}
+
+/// Deserializes a proto into the tree handle
+///
+/// - Parameters:
+///     - tree_handle: Handle to the tree resource to be restored.
+///     - tree_config: Serialied proto string of the boosted_trees.Tree proto.
+@inlinable @inline(__always)
+public static func tensorForestTreeDeserialize(
+    treeHandle: ResourceHandle,
+    treeConfig: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("TensorForestTreeDeserialize", nOutputs)
+    op.addInput(treeHandle)
+    op.addInput(treeConfig)
+    op.execute()
+}
+
+/// Checks whether a tree has been initialized.
+///
+/// - Parameter tree_handle: Handle to the tree.
+///
+/// - Output is_initialized: Whether the tree is initialized.
+@inlinable @inline(__always)
+public static func tensorForestTreeIsInitializedOp(
+    treeHandle: ResourceHandle
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorForestTreeIsInitializedOp", nOutputs)
+    op.addInput(treeHandle)
+    return op.execute(Int(1))
+}
+
+/// Output the logits for the given input data
+///
+/// - Parameters:
+///     - tree_handle: Handle to the tree resource.
+///     - dense_features: Rank 2 dense features tensor.
+///
+/// - Attr logits_dimension: Scalar, dimension of the logits.
+///
+/// - Output logits: The logits predictions from the tree for each instance in the batch.
+@inlinable @inline(__always)
+public static func tensorForestTreePredict(
+    treeHandle: ResourceHandle,
+    denseFeatures: Tensor<Float>,
+    logitsDimension: Int64
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorForestTreePredict", nOutputs)
+    op.updateAttribute("logits_dimension", logitsDimension)
+    op.addInput(treeHandle)
+    op.addInput(denseFeatures)
+    return op.execute(Int(1))
+}
+
+/// Creates a handle to a TensorForestTreeResource
+@inlinable @inline(__always)
+public static func tensorForestTreeResourceHandleOp(
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorForestTreeResourceHandleOp", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Serializes the tree handle to a proto
+///
+/// - Parameter tree_handle: Handle to the tree resource to be serialized.
+///
+/// - Output tree_config: Serialied proto string of the tree resource.
+@inlinable @inline(__always)
+public static func tensorForestTreeSerialize(
+    treeHandle: ResourceHandle
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorForestTreeSerialize", nOutputs)
+    op.addInput(treeHandle)
+    return op.execute(Int(1))
+}
+
+/// Get the number of nodes in a tree
+///
+/// - Parameter tree_handle: Handle to the tree resource.
+///
+/// - Output tree_size: The size of the tree.
+@inlinable @inline(__always)
+public static func tensorForestTreeSize(
+    treeHandle: ResourceHandle
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorForestTreeSize", nOutputs)
+    op.addInput(treeHandle)
+    return op.execute(Int(1))
+}
+
+/// Concats all tensors in the list along the 0th dimension.
+///
+/// Requires that all tensors have the same shape except the first dimension.
+///
+/// input_handle: The input list.
+/// tensor: The concated result.
+/// lengths: Output tensor containing sizes of the 0th dimension of tensors in the list, used for computing the gradient.
+///
+@inlinable @inline(__always)
+public static func tensorListConcat<ElementDtype: TensorFlowScalar>(
+    inputHandle: VariantHandle,
+    elementShape: TensorShape?
+) -> (tensor: Tensor<ElementDtype>, lengths: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TensorListConcat", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.updateAttribute("element_shape", elementShape)
+    op.addInput(inputHandle)
+    return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func tensorListConcatLists(
+    inputA: VariantHandle,
+    inputB: VariantHandle,
+    elementDtype: TensorDataType
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListConcatLists", nOutputs)
+    op.updateAttribute("element_dtype", elementDtype)
+    op.addInput(inputA)
+    op.addInput(inputB)
+    return op.execute(Int(1))
+}
+
+/// Concats all tensors in the list along the 0th dimension.
+///
+/// Requires that all tensors have the same shape except the first dimension.
+///
+/// input_handle: The input list.
+/// element_shape: The shape of the uninitialized elements in the list. If the first
+///   dimension is not -1, it is assumed that all list elements have the same
+///   leading dim.
+/// leading_dims: The list of leading dims of uninitialized list elements. Used if
+///   the leading dim of input_handle.element_shape or the element_shape input arg
+///   is not already set.
+/// tensor: The concated result.
+/// lengths: Output tensor containing sizes of the 0th dimension of tensors in the list, used for computing the gradient.
+///
+@inlinable @inline(__always)
+public static func tensorListConcatV2<
+    ElementDtype: TensorFlowScalar,
+    ShapeType: BinaryInteger & TensorFlowScalar
+>(
+    inputHandle: VariantHandle,
+    elementShape: Tensor<ShapeType>,
+    leadingDims: Tensor<Int64>
+) -> (tensor: Tensor<ElementDtype>, lengths: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TensorListConcatV2", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.updateAttribute("shape_type", ShapeType.tensorFlowDataType)
+    op.addInput(inputHandle)
+    op.addInput(elementShape)
+    op.addInput(leadingDims)
+    return op.execute(Int(1), Int(1))
+}
+
+/// The shape of the elements of the given list, as a tensor.
+///
+///   input_handle: the list
+///   element_shape: the shape of elements of the list
+@inlinable @inline(__always)
+public static func tensorListElementShape<ShapeType: BinaryInteger & TensorFlowScalar>(
+    inputHandle: VariantHandle
+) -> Tensor<ShapeType> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListElementShape", nOutputs)
+    op.updateAttribute("shape_type", ShapeType.tensorFlowDataType)
+    op.addInput(inputHandle)
+    return op.execute(Int(1))
+}
+
+/// Creates a TensorList which, when stacked, has the value of `tensor`.
+///
+/// Each tensor in the result list corresponds to one row of the input tensor.
+///
+/// tensor: The input tensor.
+/// output_handle: The list.
+@inlinable @inline(__always)
+public static func tensorListFromTensor<
+    ElementDtype: TensorFlowScalar,
+    ShapeType: BinaryInteger & TensorFlowScalar
+>(
+    _ tensor: Tensor<ElementDtype>,
+    elementShape: Tensor<ShapeType>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListFromTensor", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.updateAttribute("shape_type", ShapeType.tensorFlowDataType)
+    op.addInput(tensor)
+    op.addInput(elementShape)
+    return op.execute(Int(1))
+}
+
+/// Creates a Tensor by indexing into the TensorList.
+///
+/// Each row in the produced Tensor corresponds to the element in the TensorList
+/// specified by the given index (see `tf.gather`).  
+///
+/// input_handle: The input tensor list.
+/// indices: The indices used to index into the list.
+/// values: The tensor.
+@inlinable @inline(__always)
+public static func tensorListGather<ElementDtype: TensorFlowScalar>(
+    inputHandle: VariantHandle,
+    indices: Tensor<Int32>,
+    elementShape: Tensor<Int32>
+) -> Tensor<ElementDtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListGather", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.addInput(inputHandle)
+    op.addInput(indices)
+    op.addInput(elementShape)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func tensorListGetItem<ElementDtype: TensorFlowScalar>(
+    inputHandle: VariantHandle,
+    index: Tensor<Int32>,
+    elementShape: Tensor<Int32>
+) -> Tensor<ElementDtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListGetItem", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.addInput(inputHandle)
+    op.addInput(index)
+    op.addInput(elementShape)
+    return op.execute(Int(1))
+}
+
+/// Returns the number of tensors in the input tensor list.
+///
+/// input_handle: the input list
+/// length: the number of tensors in the list
+@inlinable @inline(__always)
+public static func tensorListLength(
+    inputHandle: VariantHandle
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListLength", nOutputs)
+    op.addInput(inputHandle)
+    return op.execute(Int(1))
+}
+
+/// Returns the last element of the input list as well as a list with all but that element.
+///
+/// Fails if the list is empty.
+///
+/// input_handle: the input list
+/// tensor: the withdrawn last element of the list
+/// element_dtype: the type of elements in the list
+/// element_shape: the shape of the output tensor
+@inlinable @inline(__always)
+public static func tensorListPopBack<ElementDtype: TensorFlowScalar>(
+    inputHandle: VariantHandle,
+    elementShape: Tensor<Int32>
+) -> (outputHandle: VariantHandle, tensor: Tensor<ElementDtype>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TensorListPopBack", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.addInput(inputHandle)
+    op.addInput(elementShape)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Returns a list list which has the passed-in `Tensor` as last element and the other elements of the given list in `input_handle`.
+///
+/// tensor: The tensor to put on the list.
+/// input_handle: The old list.
+/// output_handle: A list with the elements of the old list followed by tensor.
+/// element_dtype: the type of elements in the list.
+/// element_shape: a shape compatible with that of elements in the list.
+@inlinable @inline(__always)
+public static func tensorListPushBack<ElementDtype: TensorFlowScalar>(
+    inputHandle: VariantHandle,
+    _ tensor: Tensor<ElementDtype>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListPushBack", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.addInput(inputHandle)
+    op.addInput(tensor)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func tensorListPushBackBatch<ElementDtype: TensorFlowScalar>(
+    inputHandles: VariantHandle,
+    _ tensor: Tensor<ElementDtype>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListPushBackBatch", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.addInput(inputHandles)
+    op.addInput(tensor)
+    return op.execute(Int(1))
+}
+
+/// List of the given size with empty elements.
+///
+/// element_shape: the shape of the future elements of the list
+/// num_elements: the number of elements to reserve
+/// handle: the output list
+/// element_dtype: the desired type of elements in the list.
+@inlinable @inline(__always)
+public static func tensorListReserve<ShapeType: BinaryInteger & TensorFlowScalar>(
+    elementShape: Tensor<ShapeType>,
+    numElements: Tensor<Int32>,
+    elementDtype: TensorDataType
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListReserve", nOutputs)
+    op.updateAttribute("element_dtype", elementDtype)
+    op.updateAttribute("shape_type", ShapeType.tensorFlowDataType)
+    op.addInput(elementShape)
+    op.addInput(numElements)
+    return op.execute(Int(1))
+}
+
+/// Resizes the list.
+///
+///
+/// input_handle: the input list
+/// size: size of the output list
+///
+@inlinable @inline(__always)
+public static func tensorListResize(
+    inputHandle: VariantHandle,
+    size: Tensor<Int32>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListResize", nOutputs)
+    op.addInput(inputHandle)
+    op.addInput(size)
+    return op.execute(Int(1))
+}
+
+/// Creates a TensorList by indexing into a Tensor.
+///
+/// Each member of the TensorList corresponds to one row of the input tensor,
+/// specified by the given index (see `tf.gather`).
+///
+/// tensor: The input tensor.
+/// indices: The indices used to index into the list.
+/// element_shape: The shape of the elements in the list (can be less specified than
+///   the shape of the tensor).  
+/// output_handle: The TensorList.
+@inlinable @inline(__always)
+public static func tensorListScatter<
+    ElementDtype: TensorFlowScalar,
+    ShapeType: BinaryInteger & TensorFlowScalar
+>(
+    _ tensor: Tensor<ElementDtype>,
+    indices: Tensor<Int32>,
+    elementShape: Tensor<ShapeType>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListScatter", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.updateAttribute("shape_type", ShapeType.tensorFlowDataType)
+    op.addInput(tensor)
+    op.addInput(indices)
+    op.addInput(elementShape)
+    return op.execute(Int(1))
+}
+
+/// Scatters tensor at indices in an input list.
+///
+/// Each member of the TensorList corresponds to one row of the input tensor,
+/// specified by the given index (see `tf.gather`).
+///
+/// input_handle: The list to scatter into.
+/// tensor: The input tensor.
+/// indices: The indices used to index into the list.
+/// output_handle: The TensorList.
+@inlinable @inline(__always)
+public static func tensorListScatterIntoExistingList<ElementDtype: TensorFlowScalar>(
+    inputHandle: VariantHandle,
+    _ tensor: Tensor<ElementDtype>,
+    indices: Tensor<Int32>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListScatterIntoExistingList", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.addInput(inputHandle)
+    op.addInput(tensor)
+    op.addInput(indices)
+    return op.execute(Int(1))
+}
+
+/// Creates a TensorList by indexing into a Tensor.
+///
+/// Each member of the TensorList corresponds to one row of the input tensor,
+/// specified by the given index (see `tf.gather`).
+///
+/// tensor: The input tensor.
+/// indices: The indices used to index into the list.
+/// element_shape: The shape of the elements in the list (can be less specified than
+///   the shape of the tensor).
+/// num_elements: The size of the output list. Must be large enough to accommodate
+///   the largest index in indices. If -1, the list is just large enough to include
+///   the largest index in indices.
+/// output_handle: The TensorList.
+@inlinable @inline(__always)
+public static func tensorListScatterV2<
+    ElementDtype: TensorFlowScalar,
+    ShapeType: BinaryInteger & TensorFlowScalar
+>(
+    _ tensor: Tensor<ElementDtype>,
+    indices: Tensor<Int32>,
+    elementShape: Tensor<ShapeType>,
+    numElements: Tensor<Int32>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListScatterV2", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.updateAttribute("shape_type", ShapeType.tensorFlowDataType)
+    op.addInput(tensor)
+    op.addInput(indices)
+    op.addInput(elementShape)
+    op.addInput(numElements)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func tensorListSetItem<ElementDtype: TensorFlowScalar>(
+    inputHandle: VariantHandle,
+    index: Tensor<Int32>,
+    item: Tensor<ElementDtype>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListSetItem", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.addInput(inputHandle)
+    op.addInput(index)
+    op.addInput(item)
+    return op.execute(Int(1))
+}
+
+/// Splits a tensor into a list.
+///
+/// list[i] corresponds to lengths[i] tensors from the input tensor.
+/// The tensor must have rank at least 1 and contain exactly sum(lengths) elements.
+///
+/// tensor: The input tensor.
+/// element_shape: A shape compatible with that of elements in the tensor.
+/// lengths: Vector of sizes of the 0th dimension of tensors in the list.
+/// output_handle: The list.
+@inlinable @inline(__always)
+public static func tensorListSplit<
+    ElementDtype: TensorFlowScalar,
+    ShapeType: BinaryInteger & TensorFlowScalar
+>(
+    _ tensor: Tensor<ElementDtype>,
+    elementShape: Tensor<ShapeType>,
+    lengths: Tensor<Int64>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListSplit", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.updateAttribute("shape_type", ShapeType.tensorFlowDataType)
+    op.addInput(tensor)
+    op.addInput(elementShape)
+    op.addInput(lengths)
+    return op.execute(Int(1))
+}
+
+/// Stacks all tensors in the list.
+///
+/// Requires that all tensors have the same shape.
+///
+/// input_handle: the input list
+/// tensor: the gathered result
+/// num_elements: optional. If not -1, the number of elements in the list.
+///
+@inlinable @inline(__always)
+public static func tensorListStack<ElementDtype: TensorFlowScalar>(
+    inputHandle: VariantHandle,
+    elementShape: Tensor<Int32>,
+    numElements: Int64 = -1
+) -> Tensor<ElementDtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorListStack", nOutputs)
+    op.updateAttribute("element_dtype", ElementDtype.tensorFlowDataType)
+    op.updateAttribute("num_elements", numElements)
+    op.addInput(inputHandle)
+    op.addInput(elementShape)
+    return op.execute(Int(1))
+}
+
+/// Adds sparse `updates` to an existing tensor according to `indices`.
+///
+/// This operation creates a new tensor by adding sparse `updates` to the passed
+/// in `tensor`.
+/// This operation is very similar to `tf.scatter_nd_add`, except that the updates
+/// are added onto an existing tensor (as opposed to a variable). If the memory
+/// for the existing tensor cannot be re-used, a copy is made and updated.
+///
+/// `indices` is an integer tensor containing indices into a new tensor of shape
+/// `shape`.  The last dimension of `indices` can be at most the rank of `shape`:
+///
+///     indices.shape[-1] <= shape.rank
+///
+/// The last dimension of `indices` corresponds to indices into elements
+/// (if `indices.shape[-1] = shape.rank`) or slices
+/// (if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
+/// `shape`.  `updates` is a tensor with shape
+///
+///     indices.shape[:-1] + shape[indices.shape[-1]:]
+///
+/// The simplest form of tensor_scatter_add is to add individual elements to a
+/// tensor by index. For example, say we want to add 4 elements in a rank-1
+/// tensor with 8 elements.
+///
+/// In Python, this scatter add operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[4], [3], [1], [7]])
+///     updates = tf.constant([9, 10, 11, 12])
+///     tensor = tf.ones([8], dtype=tf.int32)
+///     updated = tf.tensor_scatter_add(tensor, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [1, 12, 1, 11, 10, 1, 1, 13]
+///
+/// We can also, insert entire slices of a higher rank tensor all at once. For
+/// example, if we wanted to insert two slices in the first dimension of a
+/// rank-3 tensor with two matrices of new values.
+///
+/// In Python, this scatter add operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[0], [2]])
+///     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]],
+///                            [[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]]])
+///     tensor = tf.ones([4, 4, 4])
+///     updated = tf.tensor_scatter_add(tensor, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [[[6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8], [9, 9, 9, 9]],
+///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
+///      [[6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8], [9, 9, 9, 9]],
+///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+///
+/// Note that on CPU, if an out of bound index is found, an error is returned.
+/// On GPU, if an out of bound index is found, the index is ignored.
+///
+/// - Parameters:
+///     - tensor: Tensor to copy/update.
+///     - indices: Index tensor.
+///     - updates: Updates to scatter into output.
+///
+/// - Output output: A new tensor copied from tensor and updates added according to the indices.
+@inlinable @inline(__always)
+public static func tensorScatterAdd<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    _ tensor: Tensor<T>,
+    indices: Tensor<Tindices>,
+    updates: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorScatterAdd", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(tensor)
+    op.addInput(indices)
+    op.addInput(updates)
+    return op.execute(Int(1))
+}
+
+/// Subtracts sparse `updates` from an existing tensor according to `indices`.
+///
+/// This operation creates a new tensor by subtracting sparse `updates` from the
+/// passed in `tensor`.
+/// This operation is very similar to `tf.scatter_nd_sub`, except that the updates
+/// are subtracted from an existing tensor (as opposed to a variable). If the memory
+/// for the existing tensor cannot be re-used, a copy is made and updated.
+///
+/// `indices` is an integer tensor containing indices into a new tensor of shape
+/// `shape`.  The last dimension of `indices` can be at most the rank of `shape`:
+///
+///     indices.shape[-1] <= shape.rank
+///
+/// The last dimension of `indices` corresponds to indices into elements
+/// (if `indices.shape[-1] = shape.rank`) or slices
+/// (if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
+/// `shape`.  `updates` is a tensor with shape
+///
+///     indices.shape[:-1] + shape[indices.shape[-1]:]
+///
+/// The simplest form of tensor_scatter_sub is to subtract individual elements
+/// from a tensor by index. For example, say we want to insert 4 scattered elements
+/// in a rank-1 tensor with 8 elements.
+///
+/// In Python, this scatter subtract operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[4], [3], [1], [7]])
+///     updates = tf.constant([9, 10, 11, 12])
+///     tensor = tf.ones([8], dtype=tf.int32)
+///     updated = tf.tensor_scatter_sub(tensor, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [1, -10, 1, -9, -8, 1, 1, -11]
+///
+/// We can also, insert entire slices of a higher rank tensor all at once. For
+/// example, if we wanted to insert two slices in the first dimension of a
+/// rank-3 tensor with two matrices of new values.
+///
+/// In Python, this scatter add operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[0], [2]])
+///     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]],
+///                            [[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]]])
+///     tensor = tf.ones([4, 4, 4])
+///     updated = tf.tensor_scatter_sub(tensor, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [[[-4, -4, -4, -4], [-5, -5, -5, -5], [-6, -6, -6, -6], [-7, -7, -7, -7]],
+///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
+///      [[-4, -4, -4, -4], [-5, -5, -5, -5], [-6, -6, -6, -6], [-7, -7, -7, -7]],
+///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+///
+/// Note that on CPU, if an out of bound index is found, an error is returned.
+/// On GPU, if an out of bound index is found, the index is ignored.
+///
+/// - Parameters:
+///     - tensor: Tensor to copy/update.
+///     - indices: Index tensor.
+///     - updates: Updates to scatter into output.
+///
+/// - Output output: A new tensor copied from tensor and updates subtracted according to the indices.
+@inlinable @inline(__always)
+public static func tensorScatterSub<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    _ tensor: Tensor<T>,
+    indices: Tensor<Tindices>,
+    updates: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorScatterSub", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(tensor)
+    op.addInput(indices)
+    op.addInput(updates)
+    return op.execute(Int(1))
+}
+
+/// Scatter `updates` into an existing tensor according to `indices`.
+///
+/// This operation creates a new tensor by applying sparse `updates` to the passed
+/// in `tensor`.
+/// This operation is very similar to `tf.scatter_nd`, except that the updates are
+/// scattered onto an existing tensor (as opposed to a zero-tensor). If the memory
+/// for the existing tensor cannot be re-used, a copy is made and updated.
+///
+/// If `indices` contains duplicates, then their updates are accumulated (summed).
+///
+/// **WARNING**: The order in which updates are applied is nondeterministic, so the
+/// output will be nondeterministic if `indices` contains duplicates -- because
+/// of some numerical approximation issues, numbers summed in different order
+/// may yield different results.
+///
+/// `indices` is an integer tensor containing indices into a new tensor of shape
+/// `shape`.  The last dimension of `indices` can be at most the rank of `shape`:
+///
+///     indices.shape[-1] <= shape.rank
+///
+/// The last dimension of `indices` corresponds to indices into elements
+/// (if `indices.shape[-1] = shape.rank`) or slices
+/// (if `indices.shape[-1] < shape.rank`) along dimension `indices.shape[-1]` of
+/// `shape`.  `updates` is a tensor with shape
+///
+///     indices.shape[:-1] + shape[indices.shape[-1]:]
+///
+/// The simplest form of scatter is to insert individual elements in a tensor by
+/// index. For example, say we want to insert 4 scattered elements in a rank-1
+/// tensor with 8 elements.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/ScatterNd1.png" alt>
+/// </div>
+///
+/// In Python, this scatter operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[4], [3], [1], [7]])
+///     updates = tf.constant([9, 10, 11, 12])
+///     tensor = tf.ones([8], dtype=tf.int32)
+///     updated = tf.tensor_scatter_update(tensor, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [1, 11, 1, 10, 9, 1, 1, 12]
+///
+/// We can also, insert entire slices of a higher rank tensor all at once. For
+/// example, if we wanted to insert two slices in the first dimension of a
+/// rank-3 tensor with two matrices of new values.
+///
+/// In Python, this scatter operation would look like this:
+///
+/// ```python
+///     indices = tf.constant([[0], [2]])
+///     updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]],
+///                            [[5, 5, 5, 5], [6, 6, 6, 6],
+///                             [7, 7, 7, 7], [8, 8, 8, 8]]])
+///     tensor = tf.ones([4, 4, 4])
+///     updated = tf.tensor_scatter_update(tensor, indices, updates)
+///     with tf.Session() as sess:
+///       print(sess.run(scatter))
+/// ```
+///
+/// The resulting tensor would look like this:
+///
+///     [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]],
+///      [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+///      [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+///
+/// Note that on CPU, if an out of bound index is found, an error is returned.
+/// On GPU, if an out of bound index is found, the index is ignored.
+///
+/// - Parameters:
+///     - tensor: Tensor to copy/update.
+///     - indices: Index tensor.
+///     - updates: Updates to scatter into output.
+///
+/// - Output output: A new tensor with the given shape and updates applied according
+///     to the indices.
+@inlinable @inline(__always)
+public static func tensorScatterUpdate<
+    T: TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar
+>(
+    _ tensor: Tensor<T>,
+    indices: Tensor<Tindices>,
+    updates: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorScatterUpdate", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.addInput(tensor)
+    op.addInput(indices)
+    op.addInput(updates)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that emits each dim-0 slice of `components` once.
+@inlinable @inline(__always)
+public static func tensorSliceDataset<ToutputTypes: TensorArrayProtocol>(
+    components: ToutputTypes,
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorSliceDataset", nOutputs)
+    op.updateAttribute("Toutput_types", components._typeList)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInputList(components)
+    return op.execute(Int(1))
+}
+
+/// Assign `value` to the sliced l-value reference of `input`.
+///
+/// The values of `value` are assigned to the positions in the tensor `input` that
+/// are selected by the slice parameters. The slice parameters `begin` `end`
+/// `strides` etc. work exactly as in `StridedSlice`.
+///
+/// NOTE this op currently does not support broadcasting and so `value`'s shape
+/// must be exactly the shape produced by the slice of `input`.
+@inlinable @inline(__always)
+public static func tensorStridedSliceUpdate<
+    T: TensorFlowScalar,
+    Index: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    begin: Tensor<Index>,
+    end: Tensor<Index>,
+    strides: Tensor<Index>,
+    value: Tensor<T>,
+    beginMask: Int64 = 0,
+    endMask: Int64 = 0,
+    ellipsisMask: Int64 = 0,
+    newAxisMask: Int64 = 0,
+    shrinkAxisMask: Int64 = 0
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorStridedSliceUpdate", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Index", Index.tensorFlowDataType)
+    op.updateAttribute("begin_mask", beginMask)
+    op.updateAttribute("end_mask", endMask)
+    op.updateAttribute("ellipsis_mask", ellipsisMask)
+    op.updateAttribute("new_axis_mask", newAxisMask)
+    op.updateAttribute("shrink_axis_mask", shrinkAxisMask)
+    op.addInput(input)
+    op.addInput(begin)
+    op.addInput(end)
+    op.addInput(strides)
+    op.addInput(value)
+    return op.execute(Int(1))
+}
+
+/// Outputs a `Summary` protocol buffer with a tensor.
+///
+/// This op is being phased out in favor of TensorSummaryV2, which lets callers pass
+/// a tag as well as a serialized SummaryMetadata proto string that contains
+/// plugin-specific data. We will keep this op to maintain backwards compatibility.
+///
+/// - Parameter tensor: A tensor to serialize.
+///
+/// - Attrs:
+///     - description: A json-encoded SummaryDescription proto.
+///     - labels: An unused list of strings.
+///     - display_name: An unused string.
+@inlinable @inline(__always)
+public static func tensorSummary<T: TensorFlowScalar>(
+    _ tensor: Tensor<T>,
+    description: String,
+    labels: [String],
+    displayName: String
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorSummary", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("description", description)
+    op.updateAttribute("labels", labels)
+    op.updateAttribute("display_name", displayName)
+    op.addInput(tensor)
+    return op.execute(Int(1))
+}
+
+/// Outputs a `Summary` protocol buffer with a tensor and per-plugin data.
+///
+/// - Parameters:
+///     - tag: A string attached to this summary. Used for organization in TensorBoard.
+///     - tensor: A tensor to serialize.
+///     - serialized_summary_metadata: A serialized SummaryMetadata proto. Contains plugin
+///         data.
+@inlinable @inline(__always)
+public static func tensorSummaryV2<T: TensorFlowScalar>(
+    tag: StringTensor,
+    _ tensor: Tensor<T>,
+    serializedSummaryMetadata: StringTensor
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("TensorSummaryV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(tag)
+    op.addInput(tensor)
+    op.addInput(serializedSummaryMetadata)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func testAttr<T: FloatingPoint & TensorFlowScalar>(
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("TestAttr", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func testStringOutput(
+    _ input: Tensor<Float>
+) -> (output1: Tensor<Float>, output2: StringTensor) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TestStringOutput", nOutputs)
+    op.addInput(input)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Creates a dataset that emits the lines of one or more text files.
+///
+/// - Parameters:
+///     - filenames: A scalar or a vector containing the name(s) of the file(s) to be
+///         read.
+///     - compression_type: A scalar containing either (i) the empty string (no
+///         compression), (ii) "ZLIB", or (iii) "GZIP".
+///     - buffer_size: A scalar containing the number of bytes to buffer.
+@inlinable @inline(__always)
+public static func textLineDataset(
+    filenames: StringTensor,
+    compressionType: StringTensor,
+    bufferSize: Tensor<Int64>
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TextLineDataset", nOutputs)
+    op.addInput(filenames)
+    op.addInput(compressionType)
+    op.addInput(bufferSize)
+    return op.execute(Int(1))
+}
+
+/// A Reader that outputs the lines of a file delimited by '\n'.
+///
+/// - Attrs:
+///     - skip_header_lines: Number of lines to skip from the beginning of every file.
+///     - container: If non-empty, this reader is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this reader is named in the given bucket
+///         with this shared_name. Otherwise, the node name is used instead.
+///
+/// - Output reader_handle: The handle to reference the Reader.
+@inlinable @inline(__always)
+public static func textLineReaderV2(
+    skipHeaderLines: Int64 = 0,
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("TextLineReaderV2", nOutputs)
+    op.updateAttribute("skip_header_lines", skipHeaderLines)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// Generates labels for candidate sampling with a learned unigram distribution.
+///
+/// See explanations of candidate sampling and the data formats at
+/// go/candidate-sampling.
+///
+/// For each batch, this op picks a single set of sampled candidate labels.
+///
+/// The advantages of sampling candidates per-batch are simplicity and the
+/// possibility of efficient dense matrix multiplication. The disadvantage is that
+/// the sampled candidates must be chosen independently of the context and of the
+/// true labels.
+///
+/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
+///     IDs of the num_true target_classes in the corresponding original label.
+///
+/// - Attrs:
+///     - num_true: Number of true labels per context.
+///     - num_sampled: Number of candidates to randomly sample.
+///     - unique: If unique is true, we sample with rejection, so that all sampled
+///         candidates in a batch are unique. This requires some approximation to
+///         estimate the post-rejection sampling probabilities.
+///     - range_max: The sampler will sample integers from the interval [0, range_max).
+///     - seed: If either seed or seed2 are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///     - sampled_candidates: A vector of length num_sampled, in which each element is
+///         the ID of a sampled candidate.
+///     - true_expected_count: A batch_size * num_true matrix, representing
+///         the number of times each candidate is expected to occur in a batch
+///         of sampled candidates. If unique=true, then this is a probability.
+///     - sampled_expected_count: A vector of length num_sampled, for each sampled
+///         candidate representing the number of times the candidate is expected
+///         to occur in a batch of sampled candidates.  If unique=true, then this is a
+///         probability.
+@inlinable @inline(__always)
+public static func threadUnsafeUnigramCandidateSampler(
+    trueClasses: Tensor<Int64>,
+    numTrue: Int64,
+    numSampled: Int64,
+    unique: Bool,
+    rangeMax: Int64,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("ThreadUnsafeUnigramCandidateSampler", nOutputs)
+    op.updateAttribute("num_true", numTrue)
+    op.updateAttribute("num_sampled", numSampled)
+    op.updateAttribute("unique", unique)
+    op.updateAttribute("range_max", rangeMax)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(trueClasses)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Constructs a tensor by tiling a given tensor.
+///
+/// This operation creates a new tensor by replicating `input` `multiples` times.
+/// The output tensor's i'th dimension has `input.dims(i) * multiples[i]` elements,
+/// and the values of `input` are replicated `multiples[i]` times along the 'i'th
+/// dimension. For example, tiling `[a b c d]` by `[2]` produces
+/// `[a b c d a b c d]`.
+///
+/// - Parameters:
+///     - input: 1-D or higher.
+///     - multiples: 1-D. Length must be the same as the number of dimensions in `input`
+@inlinable @inline(__always)
+public static func tile<
+    T: TensorFlowScalar,
+    Tmultiples: BinaryInteger & TensorFlowScalar
+>(
+    _ input: Tensor<T>,
+    multiples: Tensor<Tmultiples>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Tile", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tmultiples", Tmultiples.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(multiples)
+    return op.execute(Int(1))
+}
+
+/// Returns the gradient of `Tile`.
+///
+/// Since `Tile` takes an input and repeats the input `multiples` times
+/// along each dimension, `TileGrad` takes in `multiples` and aggregates
+/// each repeated tile of `input` into `output`.
+@inlinable @inline(__always)
+public static func tileGrad<T: TensorFlowScalar>(
+    _ input: Tensor<T>,
+    multiples: Tensor<Int32>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("TileGrad", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(multiples)
+    return op.execute(Int(1))
+}
+
+/// Provides the time since epoch in seconds.
+///
+/// Returns the timestamp as a `float64` for seconds since the Unix epoch.
+///
+/// Note: the timestamp is computed when the op is executed, not when it is added
+/// to the graph.
+@inlinable @inline(__always)
+public static func timestamp(
+) -> Tensor<Double> {
+  let nOutputs = Int(1)
+    let op = makeOp("Timestamp", nOutputs)
+    
+    return op.execute(Int(1))
+}
+
+/// Finds values and indices of the `k` largest elements for the last dimension.
+///
+/// If the input is a vector (rank-1), finds the `k` largest entries in the vector
+/// and outputs their values and indices as vectors.  Thus `values[j]` is the
+/// `j`-th largest entry in `input`, and its index is `indices[j]`.
+///
+/// For matrices (resp. higher rank input), computes the top `k` entries in each
+/// row (resp. vector along the last dimension).  Thus,
+///
+///     values.shape = indices.shape = input.shape[:-1] + [k]
+///
+/// If two elements are equal, the lower-index element appears first.
+///
+/// If `k` varies dynamically, use `TopKV2` below.
+///
+/// - Parameter input: 1-D or higher with last dimension at least `k`.
+///
+/// - Attrs:
+///     - k: Number of top elements to look for along the last dimension (along each
+///         row for matrices).
+///     - sorted: If true the resulting `k` elements will be sorted by the values in
+///         descending order.
+///
+/// - Outputs:
+///     - values: The `k` largest elements along each last dimensional slice.
+///     - indices: The indices of `values` within the last dimension of `input`.
+@inlinable @inline(__always)
+public static func topK<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    k: Int64,
+    sorted: Bool = true
+) -> (values: Tensor<T>, indices: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TopK", nOutputs)
+    op.updateAttribute("k", k)
+    op.updateAttribute("sorted", sorted)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Finds values and indices of the `k` largest elements for the last dimension.
+///
+/// If the input is a vector (rank-1), finds the `k` largest entries in the vector
+/// and outputs their values and indices as vectors.  Thus `values[j]` is the
+/// `j`-th largest entry in `input`, and its index is `indices[j]`.
+///
+/// For matrices (resp. higher rank input), computes the top `k` entries in each
+/// row (resp. vector along the last dimension).  Thus,
+///
+///     values.shape = indices.shape = input.shape[:-1] + [k]
+///
+/// If two elements are equal, the lower-index element appears first.
+///
+/// - Parameters:
+///     - input: 1-D or higher with last dimension at least `k`.
+///     - k: 0-D.  Number of top elements to look for along the last dimension (along each
+///         row for matrices).
+///
+/// - Attr sorted: If true the resulting `k` elements will be sorted by the values in
+///     descending order.
+///
+/// - Outputs:
+///     - values: The `k` largest elements along each last dimensional slice.
+///     - indices: The indices of `values` within the last dimension of `input`.
+@inlinable @inline(__always)
+public static func topKV2<T: Numeric & TensorFlowScalar>(
+    _ input: Tensor<T>,
+    k: Tensor<Int32>,
+    sorted: Bool = true
+) -> (values: Tensor<T>, indices: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TopKV2", nOutputs)
+    op.updateAttribute("sorted", sorted)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    op.addInput(k)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Shuffle dimensions of x according to a permutation.
+///
+/// The output `y` has the same rank as `x`. The shapes of `x` and `y` satisfy:
+///   `y.shape[i] == x.shape[perm[i]] for i in [0, 1, ..., rank(x) - 1]`
+@inlinable @inline(__always)
+public static func transpose<
+    T: TensorFlowScalar,
+    Tperm: BinaryInteger & TensorFlowScalar
+>(
+    _ x: Tensor<T>,
+    perm: Tensor<Tperm>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Transpose", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tperm", Tperm.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(perm)
+    return op.execute(Int(1))
+}
+
+/// Solves tridiagonal systems of equations.
+///
+/// `diagonals` is a tensor of shape `[..., 3, M]` whose inner-most 2 dimensions
+/// represent matrices with three rows being the superdiagonal, diagonals, and
+/// subdiagonals, in order. The last element of the superdiagonal and the first
+/// element of the subdiagonal is ignored.
+/// `rhs` is a tensor of shape `[..., M, K]`, representing K right-hand sides per
+/// each left-hand side.
+/// The output is a tensor of shape `[..., M, K]` containing the solutions.
+///
+/// - Parameters:
+///     - diagonals: Shape is `[..., 3, M]`.
+///     - rhs: Shape is `[..., M, K]`.
+///
+/// - Output output: Shape is `[..., M, K]`.
+@inlinable @inline(__always)
+public static func tridiagonalSolve<T: FloatingPoint & TensorFlowScalar>(
+    diagonals: Tensor<T>,
+    rhs: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("TridiagonalSolve", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(diagonals)
+    op.addInput(rhs)
+    return op.execute(Int(1))
+}
+
+/// Returns x / y element-wise for integer types.
+///
+/// Truncation designates that negative numbers will round fractional quantities
+/// toward zero. I.e. -7 / 5 = -1. This matches C semantics but it is different
+/// than Python semantics. See `FloorDiv` for a division function that matches
+/// Python Semantics.
+///
+/// *NOTE*: `TruncateDiv` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func truncateDiv<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("TruncateDiv", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns element-wise remainder of division. This emulates C semantics in that
+///
+/// the result here is consistent with a truncating divide. E.g. `truncate(x / y) *
+/// y + truncate_mod(x, y) = x`.
+///
+/// *NOTE*: `TruncateMod` supports broadcasting. More about broadcasting
+/// [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)
+@inlinable @inline(__always)
+public static func truncateMod<T: Numeric & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("TruncateMod", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Outputs random values from a truncated normal distribution.
+///
+/// The generated values follow a normal distribution with mean 0 and standard
+/// deviation 1, except that values whose magnitude is more than 2 standard
+/// deviations from the mean are dropped and re-picked.
+///
+/// - Parameter shape: The shape of the output tensor.
+///
+/// - Attrs:
+///     - seed: If either `seed` or `seed2` are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: A second seed to avoid seed collision.
+///     - dtype: The type of the output.
+///
+/// - Output output: A tensor of the specified shape filled with random truncated normal
+///     values.
+@inlinable @inline(__always)
+public static func truncatedNormal<
+    Dtype: FloatingPoint & TensorFlowScalar,
+    T: BinaryInteger & TensorFlowScalar
+>(
+    shape: Tensor<T>,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> Tensor<Dtype> {
+  let nOutputs = Int(1)
+    let op = makeOp("TruncatedNormal", nOutputs)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.updateAttribute("dtype", Dtype.tensorFlowDataType)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(shape)
+    return op.execute(Int(1))
+}
+
+/// Perform batches of RPC requests.
+///
+/// This op asynchronously performs either a single RPC request, or a batch
+/// of requests.  RPC requests are defined by three main parameters:
+///
+///   - `address` (the host+port or BNS address of the request)
+///   - `method` (the method name for the request)
+///   - `request` (the serialized proto string, or vector of strings,
+///      of the RPC request argument).
+///
+/// For example, if you have an RPC service running on port localhost:2345,
+/// and its interface is configured with the following proto declaration:
+///
+/// ```
+/// service MyService {
+///   rpc MyMethod(MyRequestProto) returns (MyResponseProto) {
+///   }
+/// };
+/// ```
+///
+/// then call this op with arguments:
+///
+/// ```
+/// address = "localhost:2345"
+/// method = "MyService/MyMethod"
+/// ```
+///
+/// The `request` tensor is a string tensor representing serialized `MyRequestProto`
+/// strings; and the output string tensor `response` will have the same shape
+/// and contain (upon successful completion) corresponding serialized
+/// `MyResponseProto` strings.
+///
+/// For example, to send a single, empty, `MyRequestProto`, call
+/// this op with `request = ""`.  To send 5 **parallel** empty requests,
+/// call this op with `request = ["", "", "", "", ""]`.
+///
+/// More generally, one can create a batch of `MyRequestProto` serialized protos
+/// from regular batched tensors using the `encode_proto` op, and convert
+/// the response `MyResponseProto` serialized protos to batched tensors
+/// using the `decode_proto` op.
+///
+/// **NOTE** Working with serialized proto strings is faster than instantiating
+/// actual proto objects in memory, so no performance degradation is expected
+/// compared to writing custom kernels for this workflow.
+///
+/// Unlike the standard `Rpc` op, if the connection fails or the remote worker
+/// returns an error status, this op does **not** reraise the exception.
+/// Instead, the `status_code` and `status_message` entry for the corresponding RPC
+/// call is set with the error returned from the RPC call.  The `response` tensor
+/// will contain valid response values for those minibatch entries whose RPCs did
+/// not fail; the rest of the entries will have empty strings.
+///
+/// - Parameters:
+///     - address: `0-D` or `1-D`.  The address (i.e. host_name:port) of the RPC server.
+///         If this tensor has more than 1 element, then multiple parallel rpc requests
+///         are sent.  This argument broadcasts with `method` and `request`.
+///     - method: `0-D` or `1-D`.  The method address on the RPC server.
+///         If this tensor has more than 1 element, then multiple parallel rpc requests
+///         are sent.  This argument broadcasts with `address` and `request`.
+///     - request: `0-D` or `1-D`.  Serialized proto strings: the rpc request argument.
+///         If this tensor has more than 1 element, then multiple parallel rpc requests
+///         are sent.  This argument broadcasts with `address` and `method`.
+///
+/// - Attrs:
+///     - protocol: RPC protocol to use.  Empty string means use the default protocol.
+///         Options include 'grpc'.
+///     - fail_fast: `boolean`. If `true` (default), then failures to connect
+///         (i.e., the server does not immediately respond) cause an RPC failure.
+///     - timeout_in_ms: `int`. If `0` (default), then the kernel will run the RPC
+///         request and only time out if the RPC deadline passes or the session times out.
+///         If this value is greater than `0`, then the op will raise an exception if
+///         the RPC takes longer than `timeout_in_ms`.
+///
+/// - Outputs:
+///     - response: Same shape as `request`. Serialized proto strings: the rpc responses.
+///     - status_code: Same shape as `request`.  Values correspond to tensorflow Status enum codes.
+///     - status_message: Same shape as `request`.  Values correspond to Status messages
+///         returned from the RPC calls.
+@inlinable @inline(__always)
+public static func tryRpc(
+    address: StringTensor,
+    method: StringTensor,
+    request: StringTensor,
+    protocol_: String,
+    failFast: Bool = true,
+    timeoutInMs: Int64 = 0
+) -> (response: StringTensor, statusCode: Tensor<Int32>, statusMessage: StringTensor) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("TryRpc", nOutputs)
+    op.updateAttribute("protocol", protocol_)
+    op.updateAttribute("fail_fast", failFast)
+    op.updateAttribute("timeout_in_ms", timeoutInMs)
+    op.addInput(address)
+    op.addInput(method)
+    op.addInput(request)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func twoFloatInputs(
+    _ a: Tensor<Float>,
+    _ b: Tensor<Float>
+) {
+  let nOutputs = 0
+    let op = makeOp("TwoFloatInputs", nOutputs)
+    op.addInput(a)
+    op.addInput(b)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func twoFloatInputsFloatOutput(
+    _ a: Tensor<Float>,
+    _ b: Tensor<Float>
+) -> Tensor<Float> {
+  let nOutputs = Int(1)
+    let op = makeOp("TwoFloatInputsFloatOutput", nOutputs)
+    op.addInput(a)
+    op.addInput(b)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func twoFloatInputsIntOutput(
+    _ a: Tensor<Float>,
+    _ b: Tensor<Float>
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("TwoFloatInputsIntOutput", nOutputs)
+    op.addInput(a)
+    op.addInput(b)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func twoFloatOutputs(
+) -> (a: Tensor<Float>, b: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TwoFloatOutputs", nOutputs)
+    
+    return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func twoIntInputs(
+    _ a: Tensor<Int32>,
+    _ b: Tensor<Int32>
+) {
+  let nOutputs = 0
+    let op = makeOp("TwoIntInputs", nOutputs)
+    op.addInput(a)
+    op.addInput(b)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func twoIntOutputs(
+) -> (a: Tensor<Int32>, b: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("TwoIntOutputs", nOutputs)
+    
+    return op.execute(Int(1), Int(1))
+}
+
+@inlinable @inline(__always)
+public static func typeList<T: TensorArrayProtocol>(
+    _ a: T
+) {
+  let nOutputs = 0
+    let op = makeOp("TypeList", nOutputs)
+    op.updateAttribute("T", a._typeList)
+    op.addInputList(a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func typeListRestrict<T: TensorArrayProtocol>(
+    _ a: T
+) {
+  let nOutputs = 0
+    let op = makeOp("TypeListRestrict", nOutputs)
+    op.updateAttribute("T", a._typeList)
+    op.addInputList(a)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func typeListTwice<T: TensorArrayProtocol>(
+    _ a: T,
+    _ b: T
+) {
+  let nOutputs = 0
+    let op = makeOp("TypeListTwice", nOutputs)
+    op.updateAttribute("T", a._typeList)
+    op.addInputList(a)
+    op.addInputList(b)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func unary<T: TensorFlowScalar>(
+    _ a: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Unary", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(a)
+    return op.execute(Int(1))
+}
+
+/// Reverses the operation of Batch for a single output Tensor.
+///
+/// An instance of Unbatch either receives an empty batched_tensor, in which case it
+/// asynchronously waits until the values become available from a concurrently
+/// running instance of Unbatch with the same container and shared_name, or receives
+/// a non-empty batched_tensor in which case it finalizes all other concurrently
+/// running instances and outputs its own element from the batch.
+///
+/// batched_tensor: The possibly transformed output of Batch. The size of the first
+///  dimension should remain unchanged by the transformations for the operation to
+///  work.
+/// batch_index: The matching batch_index obtained from Batch.
+/// id: The id scalar emitted by Batch.
+/// unbatched_tensor: The Tensor corresponding to this execution.
+/// timeout_micros: Maximum amount of time (in microseconds) to wait to receive the
+///  batched input tensor associated with a given invocation of the op.
+/// container: Container to control resource sharing.
+/// shared_name: Instances of Unbatch with the same container and shared_name are
+///  assumed to possibly belong to the same batch. If left empty, the op name will
+///  be used as the shared name.
+@inlinable @inline(__always)
+public static func unbatch<T: TensorFlowScalar>(
+    batchedTensor: Tensor<T>,
+    batchIndex: Tensor<Int64>,
+    id: Tensor<Int64>,
+    timeoutMicros: Int64,
+    container: String,
+    sharedName: String
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Unbatch", nOutputs)
+    op.updateAttribute("timeout_micros", timeoutMicros)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(batchedTensor)
+    op.addInput(batchIndex)
+    op.addInput(id)
+    return op.execute(Int(1))
+}
+
+/// Gradient of Unbatch.
+///
+/// Acts like Batch but using the given batch_index index of batching things as they
+/// become available. This ensures that the gradients are propagated back in the
+/// same session which did the forward pass.
+///
+/// original_input: The input to the Unbatch operation this is the gradient of.
+/// batch_index: The batch_index given to the Unbatch operation this is the gradient
+/// of.
+/// grad: The downstream gradient.
+/// id: The id scalar emitted by Batch.
+/// batched_grad: The return value, either an empty tensor or the batched gradient.
+/// container: Container to control resource sharing.
+/// shared_name: Instances of UnbatchGrad with the same container and shared_name
+///  are assumed to possibly belong to the same batch. If left empty, the op name
+///  will be used as the shared name.
+@inlinable @inline(__always)
+public static func unbatchGrad<T: TensorFlowScalar>(
+    originalInput: Tensor<T>,
+    batchIndex: Tensor<Int64>,
+    grad: Tensor<T>,
+    id: Tensor<Int64>,
+    container: String,
+    sharedName: String
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("UnbatchGrad", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(originalInput)
+    op.addInput(batchIndex)
+    op.addInput(grad)
+    op.addInput(id)
+    return op.execute(Int(1))
+}
+
+/// Decodes each string in `input` into a sequence of Unicode code points.
+///
+/// The character codepoints for all strings are returned using a single vector
+/// `char_values`, with strings expanded to characters in row-major order.
+///
+/// The `row_splits` tensor indicates where the codepoints for
+/// each input string begin and end within the `char_values` tensor.
+/// In particular, the values for the `i`th
+/// string (in row-major order) are stored in the slice
+/// `[row_splits[i]:row_splits[i+1]]`. Thus:
+///
+/// * `char_values[row_splits[i]+j]` is the Unicode codepoint for the `j`th
+///   character in the `i`th string (in row-major order).
+/// * `row_splits[i+1] - row_splits[i]` is the number of characters in the `i`th
+///   string (in row-major order).
+///
+/// - Parameter input: The text to be decoded. Can have any shape. Note that the output is flattened
+///     to a vector of char values.
+///
+/// - Attrs:
+///     - input_encoding: Text encoding of the input strings. This is any of the encodings supported
+///         by ICU ucnv algorithmic converters. Examples: `"UTF-16", "US ASCII", "UTF-8"`.
+///     - errors: Error handling policy when there is invalid formatting found in the input.
+///         The value of 'strict' will cause the operation to produce a InvalidArgument
+///         error on any invalid input formatting. A value of 'replace' (the default) will
+///         cause the operation to replace any invalid formatting in the input with the
+///         `replacement_char` codepoint. A value of 'ignore' will cause the operation to
+///         skip any invalid formatting in the input and produce no corresponding output
+///         character.
+///     - replacement_char: The replacement character codepoint to be used in place of any invalid
+///         formatting in the input when `errors='replace'`. Any valid unicode codepoint may
+///         be used. The default value is the default unicode replacement character is
+///         0xFFFD or U+65533.)
+///     - replace_control_characters: Whether to replace the C0 control characters (00-1F) with the
+///         `replacement_char`. Default is false.
+///
+/// - Outputs:
+///     - row_splits: A 1D int32 tensor containing the row splits.
+///     - char_values: A 1D int32 Tensor containing the decoded codepoints.
+@inlinable @inline(__always)
+public static func unicodeDecode(
+    _ input: StringTensor,
+    inputEncoding: String,
+    errors: Errors = .replace,
+    replacementChar: Int64 = 65533,
+    replaceControlCharacters: Bool = false
+) -> (rowSplits: Tensor<Int64>, charValues: Tensor<Int32>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("UnicodeDecode", nOutputs)
+    op.updateAttribute("input_encoding", inputEncoding)
+    op.updateAttribute("errors", errors.cName)
+    op.updateAttribute("replacement_char", replacementChar)
+    op.updateAttribute("replace_control_characters", replaceControlCharacters)
+    op.addInput(input)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Decodes each string in `input` into a sequence of Unicode code points.
+///
+/// The character codepoints for all strings are returned using a single vector
+/// `char_values`, with strings expanded to characters in row-major order.
+/// Similarly, the character start byte offsets are returned using a single vector
+/// `char_to_byte_starts`, with strings expanded in row-major order.
+///
+/// The `row_splits` tensor indicates where the codepoints and start offsets for
+/// each input string begin and end within the `char_values` and
+/// `char_to_byte_starts` tensors.  In particular, the values for the `i`th
+/// string (in row-major order) are stored in the slice
+/// `[row_splits[i]:row_splits[i+1]]`. Thus:
+///
+/// * `char_values[row_splits[i]+j]` is the Unicode codepoint for the `j`th
+///   character in the `i`th string (in row-major order).
+/// * `char_to_bytes_starts[row_splits[i]+j]` is the start byte offset for the `j`th
+///   character in the `i`th string (in row-major order).
+/// * `row_splits[i+1] - row_splits[i]` is the number of characters in the `i`th
+///   string (in row-major order).
+///
+/// - Parameter input: The text to be decoded. Can have any shape. Note that the output is flattened
+///     to a vector of char values.
+///
+/// - Attrs:
+///     - input_encoding: Text encoding of the input strings. This is any of the encodings supported
+///         by ICU ucnv algorithmic converters. Examples: `"UTF-16", "US ASCII", "UTF-8"`.
+///     - errors: Error handling policy when there is invalid formatting found in the input.
+///         The value of 'strict' will cause the operation to produce a InvalidArgument
+///         error on any invalid input formatting. A value of 'replace' (the default) will
+///         cause the operation to replace any invalid formatting in the input with the
+///         `replacement_char` codepoint. A value of 'ignore' will cause the operation to
+///         skip any invalid formatting in the input and produce no corresponding output
+///         character.
+///     - replacement_char: The replacement character codepoint to be used in place of any invalid
+///         formatting in the input when `errors='replace'`. Any valid unicode codepoint may
+///         be used. The default value is the default unicode replacement character is
+///         0xFFFD or U+65533.)
+///     - replace_control_characters: Whether to replace the C0 control characters (00-1F) with the
+///         `replacement_char`. Default is false.
+///
+/// - Outputs:
+///     - row_splits: A 1D int32 tensor containing the row splits.
+///     - char_values: A 1D int32 Tensor containing the decoded codepoints.
+///     - char_to_byte_starts: A 1D int32 Tensor containing the byte index in the input string where each
+///         character in `char_values` starts.
+@inlinable @inline(__always)
+public static func unicodeDecodeWithOffsets(
+    _ input: StringTensor,
+    inputEncoding: String,
+    errors: Errors = .replace,
+    replacementChar: Int64 = 65533,
+    replaceControlCharacters: Bool = false
+) -> (rowSplits: Tensor<Int64>, charValues: Tensor<Int32>, charToByteStarts: Tensor<Int64>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("UnicodeDecodeWithOffsets", nOutputs)
+    op.updateAttribute("input_encoding", inputEncoding)
+    op.updateAttribute("errors", errors.cName)
+    op.updateAttribute("replacement_char", replacementChar)
+    op.updateAttribute("replace_control_characters", replaceControlCharacters)
+    op.addInput(input)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Encode a tensor of ints into unicode strings.
+///
+/// Returns a vector of strings, where `output[i]` is constructed by encoding the
+/// Unicode codepoints in `input_values[input_splits[i]:input_splits[i+1]]`
+/// using `output_encoding`.
+///
+/// ---
+///
+/// Example:
+///
+/// ```
+/// input_values = [72, 101, 108, 108, 111, 87, 111, 114, 108, 100]
+/// input_splits = [0, 5, 10]
+/// output_encoding = 'UTF-8'
+///
+/// output = ['Hello', 'World']
+/// ```
+///
+/// - Parameters:
+///     - input_values: A 1D tensor containing the unicode codepoints that should be encoded.
+///     - input_splits: A 1D tensor specifying how the unicode codepoints should be split into strings.
+///         In particular, `output[i]` is constructed by encoding the codepoints in the
+///         slice `input_values[input_splits[i]:input_splits[i+1]]`.
+///
+/// - Attrs:
+///     - errors: Error handling policy when there is invalid formatting found in the input.
+///         The value of 'strict' will cause the operation to produce a InvalidArgument
+///         error on any invalid input formatting. A value of 'replace' (the default) will
+///         cause the operation to replace any invalid formatting in the input with the
+///         `replacement_char` codepoint. A value of 'ignore' will cause the operation to
+///         skip any invalid formatting in the input and produce no corresponding output
+///         character.
+///     - output_encoding: Unicode encoding of the output strings. Valid encodings are: `"UTF-8",
+///         "UTF-16-BE", and "UTF-32-BE"`.
+///     - replacement_char: The replacement character codepoint to be used in place of any invalid
+///         formatting in the input when `errors='replace'`. Any valid unicode codepoint may
+///         be used. The default value is the default unicode replacement character is
+///         0xFFFD (U+65533).
+///
+/// - Output output: The 1-D Tensor of strings encoded from the provided unicode codepoints.
+@inlinable @inline(__always)
+public static func unicodeEncode(
+    inputValues: Tensor<Int32>,
+    inputSplits: Tensor<Int64>,
+    errors: Errors = .replace,
+    outputEncoding: OutputEncoding,
+    replacementChar: Int64 = 65533
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("UnicodeEncode", nOutputs)
+    op.updateAttribute("errors", errors.cName)
+    op.updateAttribute("output_encoding", outputEncoding.cName)
+    op.updateAttribute("replacement_char", replacementChar)
+    op.addInput(inputValues)
+    op.addInput(inputSplits)
+    return op.execute(Int(1))
+}
+
+/// Determine the script codes of a given tensor of Unicode integer code points.
+///
+/// This operation converts Unicode code points to script codes corresponding to
+/// each code point. Script codes correspond to International Components for
+/// Unicode (ICU) UScriptCode values. See http://icu-project.org/apiref/icu4c/uscript_8h.html.
+/// Returns -1 (USCRIPT_INVALID_CODE) for invalid codepoints. Output shape will
+/// match input shape.
+///
+/// - Parameter input: A Tensor of int32 Unicode code points.
+///
+/// - Output output: A Tensor of int32 script codes corresponding to each input code point.
+@inlinable @inline(__always)
+public static func unicodeScript(
+    _ input: Tensor<Int32>
+) -> Tensor<Int32> {
+  let nOutputs = Int(1)
+    let op = makeOp("UnicodeScript", nOutputs)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Transcode the input text from a source encoding to a destination encoding.
+///
+/// The input is a string tensor of any shape. The output is a string tensor of
+/// the same shape containing the transcoded strings. Output strings are always
+/// valid unicode. If the input contains invalid encoding positions, the
+/// `errors` attribute sets the policy for how to deal with them. If the default
+/// error-handling policy is used, invalid formatting will be substituted in the
+/// output by the `replacement_char`. If the errors policy is to `ignore`, any
+/// invalid encoding positions in the input are skipped and not included in the
+/// output. If it set to `strict` then any invalid formatting will result in an
+/// InvalidArgument error.
+///
+/// This operation can be used with `output_encoding = input_encoding` to enforce
+/// correct formatting for inputs even if they are already in the desired encoding.
+///
+/// If the input is prefixed by a Byte Order Mark needed to determine encoding
+/// (e.g. if the encoding is UTF-16 and the BOM indicates big-endian), then that
+/// BOM will be consumed and not emitted into the output. If the input encoding
+/// is marked with an explicit endianness (e.g. UTF-16-BE), then the BOM is
+/// interpreted as a non-breaking-space and is preserved in the output (including
+/// always for UTF-8).
+///
+/// The end result is that if the input is marked as an explicit endianness the
+/// transcoding is faithful to all codepoints in the source. If it is not marked
+/// with an explicit endianness, the BOM is not considered part of the string itself
+/// but as metadata, and so is not preserved in the output.
+///
+/// - Parameter input: The text to be processed. Can have any shape.
+///
+/// - Attrs:
+///     - input_encoding: Text encoding of the input strings. This is any of the encodings supported
+///         by ICU ucnv algorithmic converters. Examples: `"UTF-16", "US ASCII", "UTF-8"`.
+///     - output_encoding: The unicode encoding to use in the output. Must be one of
+///         `"UTF-8", "UTF-16-BE", "UTF-32-BE"`. Multi-byte encodings will be big-endian.
+///     - errors: Error handling policy when there is invalid formatting found in the input.
+///         The value of 'strict' will cause the operation to produce a InvalidArgument
+///         error on any invalid input formatting. A value of 'replace' (the default) will
+///         cause the operation to replace any invalid formatting in the input with the
+///         `replacement_char` codepoint. A value of 'ignore' will cause the operation to
+///         skip any invalid formatting in the input and produce no corresponding output
+///         character.
+///     - replacement_char: The replacement character codepoint to be used in place of any invalid
+///         formatting in the input when `errors='replace'`. Any valid unicode codepoint may
+///         be used. The default value is the default unicode replacement character is
+///         0xFFFD or U+65533.)
+///
+///         Note that for UTF-8, passing a replacement character expressible in 1 byte, such
+///         as ' ', will preserve string alignment to the source since invalid bytes will be
+///         replaced with a 1-byte replacement. For UTF-16-BE and UTF-16-LE, any 1 or 2 byte
+///         replacement character will preserve byte alignment to the source.
+///     - replace_control_characters: Whether to replace the C0 control characters (00-1F) with the
+///         `replacement_char`. Default is false.
+///
+/// - Output output: A string tensor containing unicode text encoded using `output_encoding`.
+@inlinable @inline(__always)
+public static func unicodeTranscode(
+    _ input: StringTensor,
+    inputEncoding: String,
+    outputEncoding: OutputEncoding,
+    errors: Errors = .replace,
+    replacementChar: Int64 = 65533,
+    replaceControlCharacters: Bool = false
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("UnicodeTranscode", nOutputs)
+    op.updateAttribute("input_encoding", inputEncoding)
+    op.updateAttribute("output_encoding", outputEncoding.cName)
+    op.updateAttribute("errors", errors.cName)
+    op.updateAttribute("replacement_char", replacementChar)
+    op.updateAttribute("replace_control_characters", replaceControlCharacters)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Generates labels for candidate sampling with a uniform distribution.
+///
+/// See explanations of candidate sampling and the data formats at
+/// go/candidate-sampling.
+///
+/// For each batch, this op picks a single set of sampled candidate labels.
+///
+/// The advantages of sampling candidates per-batch are simplicity and the
+/// possibility of efficient dense matrix multiplication. The disadvantage is that
+/// the sampled candidates must be chosen independently of the context and of the
+/// true labels.
+///
+/// - Parameter true_classes: A batch_size * num_true matrix, in which each row contains the
+///     IDs of the num_true target_classes in the corresponding original label.
+///
+/// - Attrs:
+///     - num_true: Number of true labels per context.
+///     - num_sampled: Number of candidates to randomly sample.
+///     - unique: If unique is true, we sample with rejection, so that all sampled
+///         candidates in a batch are unique. This requires some approximation to
+///         estimate the post-rejection sampling probabilities.
+///     - range_max: The sampler will sample integers from the interval [0, range_max).
+///     - seed: If either seed or seed2 are set to be non-zero, the random number
+///         generator is seeded by the given seed.  Otherwise, it is seeded by a
+///         random seed.
+///     - seed2: An second seed to avoid seed collision.
+///
+/// - Outputs:
+///     - sampled_candidates: A vector of length num_sampled, in which each element is
+///         the ID of a sampled candidate.
+///     - true_expected_count: A batch_size * num_true matrix, representing
+///         the number of times each candidate is expected to occur in a batch
+///         of sampled candidates. If unique=true, then this is a probability.
+///     - sampled_expected_count: A vector of length num_sampled, for each sampled
+///         candidate representing the number of times the candidate is expected
+///         to occur in a batch of sampled candidates.  If unique=true, then this is a
+///         probability.
+@inlinable @inline(__always)
+public static func uniformCandidateSampler(
+    trueClasses: Tensor<Int64>,
+    numTrue: Int64,
+    numSampled: Int64,
+    unique: Bool,
+    rangeMax: Int64,
+    seed: Int64 = 0,
+    seed2: Int64 = 0
+) -> (sampledCandidates: Tensor<Int64>, trueExpectedCount: Tensor<Float>, sampledExpectedCount: Tensor<Float>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("UniformCandidateSampler", nOutputs)
+    op.updateAttribute("num_true", numTrue)
+    op.updateAttribute("num_sampled", numSampled)
+    op.updateAttribute("unique", unique)
+    op.updateAttribute("range_max", rangeMax)
+    op.updateAttribute("seed", seed)
+    op.updateAttribute("seed2", seed2)
+    op.addInput(trueClasses)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Finds unique elements in a 1-D tensor.
+///
+/// This operation returns a tensor `y` containing all of the unique elements of `x`
+/// sorted in the same order that they occur in `x`. This operation also returns a
+/// tensor `idx` the same size as `x` that contains the index of each value of `x`
+/// in the unique output `y`. In other words:
+///
+/// `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+///
+/// For example:
+///
+/// ```
+/// # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
+/// y, idx = unique(x)
+/// y ==> [1, 2, 4, 7, 8]
+/// idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
+/// ```
+///
+/// - Parameter x: 1-D.
+///
+/// - Outputs:
+///     - y: 1-D.
+///     - idx: 1-D.
+@inlinable @inline(__always)
+public static func unique<
+    T: TensorFlowScalar,
+    OutIdx: BinaryInteger & TensorFlowScalar
+>(
+    _ x: Tensor<T>
+) -> (y: Tensor<T>, idx: Tensor<OutIdx>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("Unique", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_idx", OutIdx.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Finds unique elements along an axis of a tensor.
+///
+/// This operation either returns a tensor `y` containing unique elements
+/// along the `axis` of a tensor. The returned unique elements is sorted
+/// in the same order as they occur along `axis` in `x`.
+/// This operation also returns a tensor `idx` that is the same size as
+/// the number of the elements in `x` along the `axis` dimension. It
+/// contains the index in the unique output `y`.
+/// In other words, for an `1-D` tensor `x` with `axis = None:
+///
+/// `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+///
+/// For example:
+///
+/// ```
+/// # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
+/// y, idx = unique(x)
+/// y ==> [1, 2, 4, 7, 8]
+/// idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
+/// ```
+///
+/// For an `2-D` tensor `x` with `axis = 0`:
+///
+/// ```
+/// # tensor 'x' is [[1, 0, 0],
+/// #                [1, 0, 0],
+/// #                [2, 0, 0]]
+/// y, idx = unique(x, axis=0)
+/// y ==> [[1, 0, 0],
+///        [2, 0, 0]]
+/// idx ==> [0, 0, 1]
+/// ```
+///
+/// For an `2-D` tensor `x` with `axis = 1`:
+///
+/// ```
+/// # tensor 'x' is [[1, 0, 0],
+/// #                [1, 0, 0],
+/// #                [2, 0, 0]]
+/// y, idx = unique(x, axis=1)
+/// y ==> [[1, 0],
+///        [1, 0],
+///        [2, 0]]
+/// idx ==> [0, 1, 1]
+/// ```
+///
+/// - Parameters:
+///     - x: A `Tensor`.
+///     - axis: A `Tensor` of type `int32` (default: None). The axis of the Tensor to
+///         find the unique elements.
+///
+/// - Outputs:
+///     - y: A `Tensor`. Unique elements along the `axis` of `Tensor` x.
+///     - idx: A 1-D Tensor. Has the same type as x that contains the index of each
+///         value of x in the output y.
+@inlinable @inline(__always)
+public static func uniqueV2<
+    T: TensorFlowScalar,
+    Taxis: BinaryInteger & TensorFlowScalar,
+    OutIdx: BinaryInteger & TensorFlowScalar
+>(
+    _ x: Tensor<T>,
+    axis: Tensor<Taxis>
+) -> (y: Tensor<T>, idx: Tensor<OutIdx>) {
+  let nOutputs = Int(1) + Int(1)
+    let op = makeOp("UniqueV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Taxis", Taxis.tensorFlowDataType)
+    op.updateAttribute("out_idx", OutIdx.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(axis)
+    return op.execute(Int(1), Int(1))
+}
+
+/// Finds unique elements in a 1-D tensor.
+///
+/// This operation returns a tensor `y` containing all of the unique elements of `x`
+/// sorted in the same order that they occur in `x`. This operation also returns a
+/// tensor `idx` the same size as `x` that contains the index of each value of `x`
+/// in the unique output `y`. Finally, it returns a third tensor `count` that
+/// contains the count of each element of `y` in `x`. In other words:
+///
+/// `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+///
+/// For example:
+///
+/// ```
+/// # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
+/// y, idx, count = unique_with_counts(x)
+/// y ==> [1, 2, 4, 7, 8]
+/// idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
+/// count ==> [2, 1, 3, 1, 2]
+/// ```
+///
+/// - Parameter x: 1-D.
+///
+/// - Outputs:
+///     - y: 1-D.
+///     - idx: 1-D.
+///     - count: 1-D.
+@inlinable @inline(__always)
+public static func uniqueWithCounts<
+    T: TensorFlowScalar,
+    OutIdx: BinaryInteger & TensorFlowScalar
+>(
+    _ x: Tensor<T>
+) -> (y: Tensor<T>, idx: Tensor<OutIdx>, count: Tensor<OutIdx>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("UniqueWithCounts", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_idx", OutIdx.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Finds unique elements along an axis of a tensor.
+///
+/// This operation either returns a tensor `y` containing unique elements
+/// along the `axis` of a tensor. The returned unique elements is sorted
+/// in the same order as they occur along `axis` in `x`.
+/// This operation also returns a tensor `idx` and a tensor `count`
+/// that are the same size as the number of the elements in `x` along the
+/// `axis` dimension. The `idx` contains the index in the unique output `y`
+/// and the `count` contains the count in the unique output `y`.
+/// In other words, for an `1-D` tensor `x` with `axis = None:
+///
+/// `y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]`
+///
+/// For example:
+///
+/// ```
+/// # tensor 'x' is [1, 1, 2, 4, 4, 4, 7, 8, 8]
+/// y, idx, count = unique_with_counts(x)
+/// y ==> [1, 2, 4, 7, 8]
+/// idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
+/// count ==> [2, 1, 3, 1, 2]
+/// ```
+///
+/// For an `2-D` tensor `x` with `axis = 0`:
+///
+/// ```
+/// # tensor 'x' is [[1, 0, 0],
+/// #                [1, 0, 0],
+/// #                [2, 0, 0]]
+/// y, idx, count = unique_with_counts(x, axis=0)
+/// y ==> [[1, 0, 0],
+///        [2, 0, 0]]
+/// idx ==> [0, 0, 1]
+/// count ==> [2, 1]
+/// ```
+///
+/// For an `2-D` tensor `x` with `axis = 1`:
+///
+/// ```
+/// # tensor 'x' is [[1, 0, 0],
+/// #                [1, 0, 0],
+/// #                [2, 0, 0]]
+/// y, idx, count = unique_with_counts(x, axis=1)
+/// y ==> [[1, 0],
+///        [1, 0],
+///        [2, 0]]
+/// idx ==> [0, 1, 1]
+/// count ==> [1, 2]
+/// ```
+///
+/// - Parameters:
+///     - x: A `Tensor`.
+///     - axis: A `Tensor` of type `int32` (default: None). The axis of the Tensor to
+///         find the unique elements.
+///
+/// - Outputs:
+///     - y: A `Tensor`. Unique elements along the `axis` of `Tensor` x.
+///     - idx: A 1-D Tensor. Has the same type as x that contains the index of each
+///         value of x in the output y.
+///     - count: A 1-D Tensor. The count of each value of x in the output y.
+@inlinable @inline(__always)
+public static func uniqueWithCountsV2<
+    T: TensorFlowScalar,
+    Taxis: BinaryInteger & TensorFlowScalar,
+    OutIdx: BinaryInteger & TensorFlowScalar
+>(
+    _ x: Tensor<T>,
+    axis: Tensor<Taxis>
+) -> (y: Tensor<T>, idx: Tensor<OutIdx>, count: Tensor<OutIdx>) {
+  let nOutputs = Int(1) + Int(1) + Int(1)
+    let op = makeOp("UniqueWithCountsV2", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Taxis", Taxis.tensorFlowDataType)
+    op.updateAttribute("out_idx", OutIdx.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(axis)
+    return op.execute(Int(1), Int(1), Int(1))
+}
+
+/// Unpacks a given dimension of a rank-`R` tensor into `num` rank-`(R-1)` tensors.
+///
+/// Unpacks `num` tensors from `value` by chipping it along the `axis` dimension.
+/// For example, given a tensor of shape `(A, B, C, D)`;
+///
+/// If `axis == 0` then the i'th tensor in `output` is the slice `value[i, :, :, :]`
+///   and each tensor in `output` will have shape `(B, C, D)`. (Note that the
+///   dimension unpacked along is gone, unlike `split`).
+///
+/// If `axis == 1` then the i'th tensor in `output` is the slice `value[:, i, :, :]`
+///   and each tensor in `output` will have shape `(A, C, D)`.
+/// Etc.
+///
+/// This is the opposite of `pack`.
+///
+/// - Parameter value: 1-D or higher, with `axis` dimension size equal to `num`.
+///
+/// - Attr axis: Dimension along which to unpack.  Negative values wrap around, so the
+///     valid range is `[-R, R)`.
+///
+/// - Output output: The list of tensors unpacked from `value`.
+@inlinable @inline(__always)
+public static func unpack<T: TensorFlowScalar>(
+    value: Tensor<T>,
+    num: Int64,
+    axis: Int64 = 0
+) -> [Tensor<T>] {
+  let nOutputs = Int(num)
+    let op = makeOp("Unpack", nOutputs)
+    op.updateAttribute("num", num)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("axis", axis)
+    op.addInput(value)
+    return op.execute(Int(num))
+}
+
+/// Converts a flat index or array of flat indices into a tuple of
+///
+/// coordinate arrays.
+///
+/// @compatibility(numpy)
+/// Equivalent to np.unravel_index
+/// @end_compatibility
+///
+/// - Parameters:
+///     - indices: An 0-D or 1-D `int` Tensor whose elements are indices into the
+///         flattened version of an array of dimensions dims.
+///     - dims: An 1-D `int` Tensor. The shape of the array to use for unraveling
+///         indices.
+///
+/// - Output output: An 2-D (or 1-D if indices is 0-D) tensor where each row has the
+///     same shape as the indices array.
+@inlinable @inline(__always)
+public static func unravelIndex<Tidx: BinaryInteger & TensorFlowScalar>(
+    indices: Tensor<Tidx>,
+    dims: Tensor<Tidx>
+) -> Tensor<Tidx> {
+  let nOutputs = Int(1)
+    let op = makeOp("UnravelIndex", nOutputs)
+    op.updateAttribute("Tidx", Tidx.tensorFlowDataType)
+    op.addInput(indices)
+    op.addInput(dims)
+    return op.execute(Int(1))
+}
+
+/// Computes the maximum along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// This operator is similar to the unsorted segment sum operator found
+/// [(here)](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
+/// Instead of computing the sum over segments, it computes the maximum such that:
+///
+/// \\(output_i = \max_{j...} data[j...]\\) where max is over tuples `j...` such
+/// that `segment_ids[j...] == i`.
+///
+/// If the maximum is empty for a given segment ID `i`, it outputs the smallest
+/// possible value for the specific numeric type,
+/// `output[i] = numeric_limits<T>::lowest()`.
+///
+/// If the given segment ID `i` is negative, then the corresponding value is
+/// dropped, and will not be included in the result.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/UnsortedSegmentMax.png" alt>
+/// </div>
+///
+/// For example:
+///
+/// ``` python
+/// c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]])
+/// tf.unsorted_segment_max(c, tf.constant([0, 1, 0]), num_segments=2)
+/// # ==> [[ 4,  3, 3, 4],
+/// #       [5,  6, 7, 8]]
+/// ```
+///
+///
+/// - Parameter segment_ids: A tensor whose shape is a prefix of `data.shape`.
+///
+/// - Output output: Has same shape as data, except for the first `segment_ids.rank`
+///     dimensions, which are replaced with a single dimension which has size
+///     `num_segments`.
+@inlinable @inline(__always)
+public static func unsortedSegmentMax<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    segmentIds: Tensor<Tindices>,
+    numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("UnsortedSegmentMax", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("Tnumsegments", Tnumsegments.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(segmentIds)
+    op.addInput(numSegments)
+    return op.execute(Int(1))
+}
+
+/// Computes the minimum along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// This operator is similar to the unsorted segment sum operator found
+/// [(here)](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
+/// Instead of computing the sum over segments, it computes the minimum such that:
+///
+/// \\(output_i = \min_{j...} data_[j...]\\) where min is over tuples `j...` such
+/// that `segment_ids[j...] == i`.
+///
+/// If the minimum is empty for a given segment ID `i`, it outputs the largest
+/// possible value for the specific numeric type,
+/// `output[i] = numeric_limits<T>::max()`.
+///
+/// For example:
+///
+/// ``` python
+/// c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]])
+/// tf.unsorted_segment_min(c, tf.constant([0, 1, 0]), num_segments=2)
+/// # ==> [[ 1,  2, 2, 1],
+/// #       [5,  6, 7, 8]]
+/// ```
+///
+/// If the given segment ID `i` is negative, then the corresponding value is
+/// dropped, and will not be included in the result.
+///
+/// - Parameter segment_ids: A tensor whose shape is a prefix of `data.shape`.
+///
+/// - Output output: Has same shape as data, except for the first `segment_ids.rank`
+///     dimensions, which are replaced with a single dimension which has size
+///     `num_segments`.
+@inlinable @inline(__always)
+public static func unsortedSegmentMin<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    segmentIds: Tensor<Tindices>,
+    numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("UnsortedSegmentMin", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("Tnumsegments", Tnumsegments.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(segmentIds)
+    op.addInput(numSegments)
+    return op.execute(Int(1))
+}
+
+/// Computes the product along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// This operator is similar to the unsorted segment sum operator found
+/// [(here)](../../../api_docs/python/math_ops.md#UnsortedSegmentSum).
+/// Instead of computing the sum over segments, it computes the product of all
+/// entries belonging to a segment such that:
+///
+/// \\(output_i = \prod_{j...} data[j...]\\) where the product is over tuples
+/// `j...` such that `segment_ids[j...] == i`.
+///
+/// For example:
+///
+/// ``` python
+/// c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]])
+/// tf.unsorted_segment_prod(c, tf.constant([0, 1, 0]), num_segments=2)
+/// # ==> [[ 4,  6, 6, 4],
+/// #       [5,  6, 7, 8]]
+/// ```
+///
+/// If there is no entry for a given segment ID `i`, it outputs 1.
+///
+/// If the given segment ID `i` is negative, then the corresponding value is
+/// dropped, and will not be included in the result.
+///
+/// - Parameter segment_ids: A tensor whose shape is a prefix of `data.shape`.
+///
+/// - Output output: Has same shape as data, except for the first `segment_ids.rank`
+///     dimensions, which are replaced with a single dimension which has size
+///     `num_segments`.
+@inlinable @inline(__always)
+public static func unsortedSegmentProd<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    segmentIds: Tensor<Tindices>,
+    numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("UnsortedSegmentProd", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("Tnumsegments", Tnumsegments.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(segmentIds)
+    op.addInput(numSegments)
+    return op.execute(Int(1))
+}
+
+/// Computes the sum along segments of a tensor.
+///
+/// Read
+/// [the section on segmentation](https://tensorflow.org/api_docs/python/tf/math#Segmentation)
+/// for an explanation of segments.
+///
+/// Computes a tensor such that
+/// \\(output[i] = \sum_{j...} data[j...]\\) where the sum is over tuples `j...` such
+/// that `segment_ids[j...] == i`.  Unlike `SegmentSum`, `segment_ids`
+/// need not be sorted and need not cover all values in the full
+/// range of valid values.
+///
+/// If the sum is empty for a given segment ID `i`, `output[i] = 0`.
+/// If the given segment ID `i` is negative, the value is dropped and will not be
+/// added to the sum of the segment.
+///
+/// `num_segments` should equal the number of distinct segment IDs.
+///
+/// <div style="width:70%; margin:auto; margin-bottom:10px; margin-top:20px;">
+/// <img style="width:100%" src="https://www.tensorflow.org/images/UnsortedSegmentSum.png" alt>
+/// </div>
+///
+/// ``` python
+/// c = tf.constant([[1,2,3,4], [5,6,7,8], [4,3,2,1]])
+/// tf.unsorted_segment_sum(c, tf.constant([0, 1, 0]), num_segments=2)
+/// # ==> [[ 5,  5, 5, 5],
+/// #       [5,  6, 7, 8]]
+/// ```
+///
+///
+/// - Parameter segment_ids: A tensor whose shape is a prefix of `data.shape`.
+///
+/// - Output output: Has same shape as data, except for the first `segment_ids.rank`
+///     dimensions, which are replaced with a single dimension which has size
+///     `num_segments`.
+@inlinable @inline(__always)
+public static func unsortedSegmentSum<
+    T: Numeric & TensorFlowScalar,
+    Tindices: BinaryInteger & TensorFlowScalar,
+    Tnumsegments: BinaryInteger & TensorFlowScalar
+>(
+    data: Tensor<T>,
+    segmentIds: Tensor<Tindices>,
+    numSegments: Tensor<Tnumsegments>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("UnsortedSegmentSum", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("Tindices", Tindices.tensorFlowDataType)
+    op.updateAttribute("Tnumsegments", Tnumsegments.tensorFlowDataType)
+    op.addInput(data)
+    op.addInput(segmentIds)
+    op.addInput(numSegments)
+    return op.execute(Int(1))
+}
+
+/// Op is similar to a lightweight Dequeue.
+///
+/// The basic functionality is similar to dequeue with many fewer
+/// capabilities and options.  This Op is optimized for performance.
+@inlinable @inline(__always)
+public static func unstage<Dtypes: TensorGroup>(
+    capacity: Int64 = 0,
+    memoryLimit: Int64 = 0,
+    container: String,
+    sharedName: String
+) -> Dtypes {
+  let nOutputs = Int(Dtypes._typeList.count)
+    let op = makeOp("Unstage", nOutputs)
+    op.updateAttribute("capacity", capacity)
+    op.updateAttribute("memory_limit", memoryLimit)
+    op.updateAttribute("dtypes", Dtypes._typeList)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(Dtypes._typeList.count))
+}
+
+@inlinable @inline(__always)
+public static func unwrapDatasetVariant(
+    inputHandle: VariantHandle
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("UnwrapDatasetVariant", nOutputs)
+    op.addInput(inputHandle)
+    return op.execute(Int(1))
+}
+
+/// Applies upper_bound(sorted_search_values, values) along each row.
+///
+/// Each set of rows with the same index in (sorted_inputs, values) is treated
+/// independently.  The resulting row is the equivalent of calling
+/// `np.searchsorted(sorted_inputs, values, side='right')`.
+///
+/// The result is not a global index to the entire 
+/// `Tensor`, but rather just the index in the last dimension.
+///
+/// A 2-D example:
+///   sorted_sequence = [[0, 3, 9, 9, 10],
+///                      [1, 2, 3, 4, 5]]
+///   values = [[2, 4, 9],
+///             [0, 2, 6]]
+///
+///   result = UpperBound(sorted_sequence, values)
+///
+///   result == [[1, 2, 4],
+///              [0, 2, 5]]
+///
+/// - Parameters:
+///     - sorted_inputs: 2-D Tensor where each row is ordered.
+///     - values: 2-D Tensor with the same numbers of rows as `sorted_search_values`. Contains
+///         the values that will be searched for in `sorted_search_values`.
+///
+/// - Output output: A `Tensor` with the same shape as `values`.  It contains the last scalar index
+///     into the last dimension where values can be inserted without changing the
+///     ordered property.
+@inlinable @inline(__always)
+public static func upperBound<
+    T: TensorFlowScalar,
+    OutType: BinaryInteger & TensorFlowScalar
+>(
+    sortedInputs: Tensor<T>,
+    _ values: Tensor<T>
+) -> Tensor<OutType> {
+  let nOutputs = Int(1)
+    let op = makeOp("UpperBound", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(sortedInputs)
+    op.addInput(values)
+    return op.execute(Int(1))
+}
+
+/// Creates a handle to a Variable resource.
+///
+/// - Attrs:
+///     - container: the container this variable is placed in.
+///     - shared_name: the name by which this variable is referred to.
+///     - dtype: the type of this variable. Must agree with the dtypes
+///         of all ops using this variable.
+///     - shape: The (possibly partially specified) shape of this variable.
+@inlinable @inline(__always)
+public static func varHandleOp(
+    container: String,
+    sharedName: String,
+    dtype: TensorDataType,
+    shape: TensorShape?
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("VarHandleOp", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    op.updateAttribute("dtype", dtype)
+    op.updateAttribute("shape", shape)
+    return op.execute(Int(1))
+}
+
+/// Checks whether a resource handle-based variable has been initialized.
+///
+/// - Parameter resource: the input resource handle.
+///
+/// - Output is_initialized: a scalar boolean which is true if the variable has been
+///     initialized.
+@inlinable @inline(__always)
+public static func varIsInitializedOp(
+    resource: ResourceHandle
+) -> Tensor<Bool> {
+  let nOutputs = Int(1)
+    let op = makeOp("VarIsInitializedOp", nOutputs)
+    op.addInput(resource)
+    return op.execute(Int(1))
+}
+
+/// Returns the shape of the variable pointed to by `resource`.
+///
+/// This operation returns a 1-D integer tensor representing the shape of `input`.
+///
+/// For example:
+///
+/// ```
+/// # 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
+/// shape(t) ==> [2, 2, 3]
+/// ```
+@inlinable @inline(__always)
+public static func variableShape<OutType: BinaryInteger & TensorFlowScalar>(
+    _ input: ResourceHandle
+) -> Tensor<OutType> {
+  let nOutputs = Int(1)
+    let op = makeOp("VariableShape", nOutputs)
+    op.updateAttribute("out_type", OutType.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// Returns locations of nonzero / true values in a tensor.
+///
+/// This operation returns the coordinates of true elements in `condition`. The
+/// coordinates are returned in a 2-D tensor where the first dimension (rows)
+/// represents the number of true elements, and the second dimension (columns)
+/// represents the coordinates of the true elements. Keep in mind, the shape of
+/// the output tensor can vary depending on how many true values there are in
+/// `condition`. Indices are output in row-major order.
+///
+/// For example:
+///
+/// ```
+/// # 'input' tensor is [[True, False]
+/// #                    [True, False]]
+/// # 'input' has two true values, so output has two coordinates.
+/// # 'input' has rank of 2, so coordinates have two indices.
+/// where(input) ==> [[0, 0],
+///                   [1, 0]]
+///
+/// # `condition` tensor is [[[True, False]
+/// #                     [True, False]]
+/// #                    [[False, True]
+/// #                     [False, True]]
+/// #                    [[False, False]
+/// #                     [False, True]]]
+/// # 'input' has 5 true values, so output has 5 coordinates.
+/// # 'input' has rank of 3, so coordinates have three indices.
+/// where(input) ==> [[0, 0, 0],
+///                   [0, 1, 0],
+///                   [1, 0, 1],
+///                   [1, 1, 1],
+///                   [2, 1, 1]]
+///
+/// # `condition` tensor is [[[1.5,  0.0]
+/// #                     [-0.5, 0.0]]
+/// #                    [[0.0,  0.25]
+/// #                     [0.0,  0.75]]
+/// #                    [[0.0,  0.0]
+/// #                     [0.0,  0.01]]]
+/// # 'input' has 5 nonzero values, so output has 5 coordinates.
+/// # 'input' has rank of 3, so coordinates have three indices.
+/// where(input) ==> [[0, 0, 0],
+///                   [0, 1, 0],
+///                   [1, 0, 1],
+///                   [1, 1, 1],
+///                   [2, 1, 1]]
+///
+/// # `condition` tensor is [[[1.5 + 0.0j, 0.0  + 0.0j]
+/// #                     [0.0 + 0.5j, 0.0  + 0.0j]]
+/// #                    [[0.0 + 0.0j, 0.25 + 1.5j]
+/// #                     [0.0 + 0.0j, 0.75 + 0.0j]]
+/// #                    [[0.0 + 0.0j, 0.0  + 0.0j]
+/// #                     [0.0 + 0.0j, 0.01 + 0.0j]]]
+/// # 'input' has 5 nonzero magnitude values, so output has 5 coordinates.
+/// # 'input' has rank of 3, so coordinates have three indices.
+/// where(input) ==> [[0, 0, 0],
+///                   [0, 1, 0],
+///                   [1, 0, 1],
+///                   [1, 1, 1],
+///                   [2, 1, 1]]
+/// ```
+@inlinable @inline(__always)
+public static func where_<T: TensorFlowScalar>(
+    _ input: Tensor<T>
+) -> Tensor<Int64> {
+  let nOutputs = Int(1)
+    let op = makeOp("Where", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(input)
+    return op.execute(Int(1))
+}
+
+/// output = input; While (Cond(output)) { output = Body(output) }
+///
+/// - Parameter input: A list of input tensors whose types are T.
+///
+/// - Attrs:
+///     - T: dtype in use.
+///     - cond:       A function takes 'input' and returns a tensor.  If the tensor is
+///               a scalar of non-boolean, the scalar is converted to a boolean
+///               according to the following rule: if the scalar is a numerical
+///               value, non-zero means True and zero means False; if the scalar is
+///               a string, non-empty means True and empty means False. If the
+///               tensor is not a scalar, non-emptiness means True and False
+///               otherwise.
+///     - body:       A function that takes a list of tensors and returns another
+///               list of tensors. Both lists have the same types as specified
+///               by T.
+///
+/// - Output output: A list of output tensors whose types are T.
+@inlinable @inline(__always)
+public static func while_<
+    T: TensorArrayProtocol,
+    CondIn: TensorGroup,
+    CondOut: TensorGroup,
+    BodyIn: TensorGroup,
+    BodyOut: TensorGroup
+>(
+    _ input: T,
+    cond: (CondIn) -> CondOut,
+    body: (BodyIn) -> BodyOut,
+    outputShapes: [TensorShape?],
+    parallelIterations: Int64 = 10
+) -> T {
+  let nOutputs = Int(input._typeList.count)
+    let op = makeOp("While", nOutputs)
+    op.updateAttribute("T", input._typeList)
+    op.updateAttribute("cond", cond)
+    op.updateAttribute("body", body)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("parallel_iterations", parallelIterations)
+    op.addInputList(input)
+    return op.execute(Int(input._typeList.count))
+}
+
+/// A Reader that outputs the entire contents of a file as a value.
+///
+/// To use, enqueue filenames in a Queue.  The output of ReaderRead will
+/// be a filename (key) and the contents of that file (value).
+///
+/// - Attrs:
+///     - container: If non-empty, this reader is placed in the given container.
+///         Otherwise, a default container is used.
+///     - shared_name: If non-empty, this reader is named in the given bucket
+///         with this shared_name. Otherwise, the node name is used instead.
+///
+/// - Output reader_handle: The handle to reference the Reader.
+@inlinable @inline(__always)
+public static func wholeFileReaderV2(
+    container: String,
+    sharedName: String
+) -> ResourceHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("WholeFileReaderV2", nOutputs)
+    op.updateAttribute("container", container)
+    op.updateAttribute("shared_name", sharedName)
+    return op.execute(Int(1))
+}
+
+/// A dataset that creates window datasets from the input dataset.
+///
+/// - Parameters:
+///     - size: A scalar representing the number of elements to accumulate in a window.
+///     - shift: A scalar representing the steps moving the sliding window forward in one
+///         iteration. It must be positive.
+///     - stride: A scalar representing the stride of the input elements of the sliding window.
+///         It must be positive.
+///     - drop_remainder: A scalar representing whether a window should be dropped in case its size is
+///         smaller than desired.
+@inlinable @inline(__always)
+public static func windowDataset(
+    inputDataset: VariantHandle,
+    size: Tensor<Int64>,
+    shift: Tensor<Int64>,
+    stride: Tensor<Int64>,
+    dropRemainder: Tensor<Bool>,
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("WindowDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.addInput(inputDataset)
+    op.addInput(size)
+    op.addInput(shift)
+    op.addInput(stride)
+    op.addInput(dropRemainder)
+    return op.execute(Int(1))
+}
+
+/// Worker heartbeat op.
+///
+/// Heartbeats may be sent periodically to indicate the coordinator is still active,
+/// to retrieve the current worker status and to expedite shutdown when necessary.
+///
+/// - Parameter request: A string tensor containing a serialized WorkerHeartbeatRequest
+///
+/// - Output response: A string tensor containing a serialized WorkerHeartbeatResponse
+@inlinable @inline(__always)
+public static func workerHeartbeat(
+    request: StringTensor
+) -> StringTensor {
+  let nOutputs = Int(1)
+    let op = makeOp("WorkerHeartbeat", nOutputs)
+    op.addInput(request)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func wrapDatasetVariant(
+    inputHandle: VariantHandle
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("WrapDatasetVariant", nOutputs)
+    op.addInput(inputHandle)
+    return op.execute(Int(1))
+}
+
+@inlinable @inline(__always)
+public static func writeAudioSummary(
+    writer: ResourceHandle,
+    step: Tensor<Int64>,
+    tag: StringTensor,
+    _ tensor: Tensor<Float>,
+    sampleRate: Tensor<Float>,
+    maxOutputs: Int64 = 3
+) {
+  let nOutputs = 0
+    let op = makeOp("WriteAudioSummary", nOutputs)
+    op.updateAttribute("max_outputs", maxOutputs)
+    op.addInput(writer)
+    op.addInput(step)
+    op.addInput(tag)
+    op.addInput(tensor)
+    op.addInput(sampleRate)
+    op.execute()
+}
+
+/// Writes contents to the file at input filename. Creates file and recursively
+///
+/// creates directory if not existing.
+///
+/// - Parameters:
+///     - filename: scalar. The name of the file to which we write the contents.
+///     - contents: scalar. The content to be written to the output file.
+@inlinable @inline(__always)
+public static func writeFile(
+    filename: StringTensor,
+    contents: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("WriteFile", nOutputs)
+    op.addInput(filename)
+    op.addInput(contents)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func writeGraphSummary(
+    writer: ResourceHandle,
+    step: Tensor<Int64>,
+    _ tensor: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("WriteGraphSummary", nOutputs)
+    op.addInput(writer)
+    op.addInput(step)
+    op.addInput(tensor)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func writeHistogramSummary<T: Numeric & TensorFlowScalar>(
+    writer: ResourceHandle,
+    step: Tensor<Int64>,
+    tag: StringTensor,
+    _ values: Tensor<T>
+) {
+  let nOutputs = 0
+    let op = makeOp("WriteHistogramSummary", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(writer)
+    op.addInput(step)
+    op.addInput(tag)
+    op.addInput(values)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func writeImageSummary<T: Numeric & TensorFlowScalar>(
+    writer: ResourceHandle,
+    step: Tensor<Int64>,
+    tag: StringTensor,
+    _ tensor: Tensor<T>,
+    badColor: Tensor<UInt8>,
+    maxImages: Int64 = 3
+) {
+  let nOutputs = 0
+    let op = makeOp("WriteImageSummary", nOutputs)
+    op.updateAttribute("max_images", maxImages)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(writer)
+    op.addInput(step)
+    op.addInput(tag)
+    op.addInput(tensor)
+    op.addInput(badColor)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func writeRawProtoSummary(
+    writer: ResourceHandle,
+    step: Tensor<Int64>,
+    _ tensor: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("WriteRawProtoSummary", nOutputs)
+    op.addInput(writer)
+    op.addInput(step)
+    op.addInput(tensor)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func writeScalarSummary<T: Numeric & TensorFlowScalar>(
+    writer: ResourceHandle,
+    step: Tensor<Int64>,
+    tag: StringTensor,
+    value: Tensor<T>
+) {
+  let nOutputs = 0
+    let op = makeOp("WriteScalarSummary", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(writer)
+    op.addInput(step)
+    op.addInput(tag)
+    op.addInput(value)
+    op.execute()
+}
+
+@inlinable @inline(__always)
+public static func writeSummary<T: TensorFlowScalar>(
+    writer: ResourceHandle,
+    step: Tensor<Int64>,
+    _ tensor: Tensor<T>,
+    tag: StringTensor,
+    summaryMetadata: StringTensor
+) {
+  let nOutputs = 0
+    let op = makeOp("WriteSummary", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(writer)
+    op.addInput(step)
+    op.addInput(tensor)
+    op.addInput(tag)
+    op.addInput(summaryMetadata)
+    op.execute()
+}
+
+/// Returns 0 if x == 0, and x / y otherwise, elementwise.
+@inlinable @inline(__always)
+public static func xdivy<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Xdivy", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns 0 if x == 0, and x * log(y) otherwise, elementwise.
+@inlinable @inline(__always)
+public static func xlogy<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    _ y: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Xlogy", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(y)
+    return op.execute(Int(1))
+}
+
+/// Returns a tensor of zeros with the same shape and type as x.
+///
+/// - Parameter x: a tensor of type T.
+///
+/// - Output y: a tensor of the same shape and type as x but filled with zeros.
+@inlinable @inline(__always)
+public static func zerosLike<T: TensorFlowScalar>(
+    _ x: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("ZerosLike", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    return op.execute(Int(1))
+}
+
+/// Compute the Hurwitz zeta function \\(\zeta(x, q)\\).
+///
+/// The Hurwitz zeta function is defined as:
+///
+///
+/// \\(\zeta(x, q) = \sum_{n=0}^{\infty} (q + n)^{-x}\\)
+@inlinable @inline(__always)
+public static func zeta<T: FloatingPoint & TensorFlowScalar>(
+    _ x: Tensor<T>,
+    q: Tensor<T>
+) -> Tensor<T> {
+  let nOutputs = Int(1)
+    let op = makeOp("Zeta", nOutputs)
+    op.updateAttribute("T", T.tensorFlowDataType)
+    op.addInput(x)
+    op.addInput(q)
+    return op.execute(Int(1))
+}
+
+/// Creates a dataset that zips together `input_datasets`.
+@inlinable @inline(__always)
+public static func zipDataset(
+    inputDatasets: [VariantHandle],
+    outputTypes: [TensorDataType],
+    outputShapes: [TensorShape?]
+) -> VariantHandle {
+  let nOutputs = Int(1)
+    let op = makeOp("ZipDataset", nOutputs)
+    op.updateAttribute("output_types", outputTypes)
+    op.updateAttribute("output_shapes", outputShapes)
+    op.updateAttribute("N", inputDatasets.count)
+    op.addInputList(inputDatasets)
+    return op.execute(Int(1))
+}
+
+}
diff --git a/Sources/TensorFlow/Bindings/TFTensorOperation.swift b/Sources/TensorFlow/Bindings/TFTensorOperation.swift
new file mode 100644
index 000000000..f137a3cfc
--- /dev/null
+++ b/Sources/TensorFlow/Bindings/TFTensorOperation.swift
@@ -0,0 +1,149 @@
+// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+// A protocol for a tensor operation.
+public protocol TensorOperation {
+    // We use functions instead of fields to give freedom in the representation for the conforming
+    // types.
+    init(_ name: String, _ outputCount: Int)
+
+    func updateAttribute(_ name: String, _ value: Bool)
+    func updateAttribute(_ name: String, _ value: Int)
+    func updateAttribute(_ name: String, _ value: Int32)
+    func updateAttribute(_ name: String, _ value: Int64)
+    func updateAttribute(_ name: String, _ value: Float)
+    func updateAttribute(_ name: String, _ value: Double)
+    func updateAttribute(_ name: String, _ value: String)
+    func updateAttribute(_ name: String, _ value: [Bool])
+    func updateAttribute(_ name: String, _ value: [Int])
+    func updateAttribute(_ name: String, _ value: [Int32])
+    func updateAttribute(_ name: String, _ value: [Int64])
+    func updateAttribute(_ name: String, _ value: [Float])
+    func updateAttribute(_ name: String, _ value: [Double])
+    func updateAttribute(_ name: String, _ value: [String])
+
+    // TODO(https://bugs.swift.org/browse/TF-522): When we are able to
+    // use opaque return types everywhere, we should add an
+    // associatedtype requirement and add the following methods so that
+    // we can work with non-tensorflow backends if neeeded.
+    //
+    // associatedtype TensorValueHandle
+    //
+    // func addInput(_ input: TensorValueHandle)
+    // func evaluate() -> ([TensorValueHandle])
+}
+
+// A protocol for a tensor operation in TensorFlow library.
+public protocol TFTensorOperation: TensorOperation {
+    func addInput<Scalar: TensorFlowScalar>(_ input: Tensor<Scalar>)
+    func addInput(_ input: StringTensor)
+    func addInput(_ input: VariantHandle)
+    func addInput(_ input: ResourceHandle)
+    func addInputList<T: TensorArrayProtocol>(_ input: T)
+
+    func updateAttribute(_ name: String, _ value: TensorDataType)
+    func updateAttribute(_ name: String, _ value: TensorShape)
+    func updateAttribute(_ name: String, _ value: TensorShape?)
+    func updateAttribute(_ name: String, _ value: [TensorDataType])
+    func updateAttribute(_ name: String, _ value: [TensorShape])
+    func updateAttribute(_ name: String, _ value: [TensorShape?])
+    func updateAttribute<In: TensorGroup, Out: TensorGroup>(_ name: String, _ value: (In) -> Out)
+
+    func execute()
+
+    func execute<T0: TensorArrayProtocol>(
+        _ count0: Int
+    ) -> (T0)
+
+    func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int
+    ) -> (T0, T1)
+
+    func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int
+    ) -> (T0, T1, T2)
+
+    func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int
+    ) -> (T0, T1, T2, T3)
+
+    func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int,
+        _ count4: Int
+    ) -> (T0, T1, T2, T3, T4)
+
+    func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int,
+        _ count4: Int,
+        _ count5: Int
+    ) -> (T0, T1, T2, T3, T4, T5)
+
+    func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int,
+        _ count4: Int,
+        _ count5: Int,
+        _ count6: Int
+    ) -> (T0, T1, T2, T3, T4, T5, T6)
+        
+    func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol, T7: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int,
+        _ count4: Int,
+        _ count5: Int,
+        _ count6: Int,
+        _ count7: Int
+    ) -> (T0, T1, T2, T3, T4, T5, T6, T7)
+
+    func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol, T7: TensorArrayProtocol, T8: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int,
+        _ count4: Int,
+        _ count5: Int,
+        _ count6: Int,
+        _ count7: Int,
+        _ count8: Int
+    ) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8)
+    
+    func execute<T0: TensorArrayProtocol, T1: TensorArrayProtocol, T2: TensorArrayProtocol, T3: TensorArrayProtocol, T4: TensorArrayProtocol, T5: TensorArrayProtocol, T6: TensorArrayProtocol, T7: TensorArrayProtocol, T8: TensorArrayProtocol, T9: TensorArrayProtocol>(
+        _ count0: Int,
+        _ count1: Int,
+        _ count2: Int,
+        _ count3: Int,
+        _ count4: Int,
+        _ count5: Int,
+        _ count6: Int,
+        _ count7: Int,
+        _ count8: Int,
+        _ count9: Int
+    ) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
+}
diff --git a/Sources/TensorFlow/Bindings/generate_wrappers.py b/Sources/TensorFlow/Bindings/generate_wrappers.py
new file mode 100644
index 000000000..915ab8e3b
--- /dev/null
+++ b/Sources/TensorFlow/Bindings/generate_wrappers.py
@@ -0,0 +1,716 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+
+"""Generates some swift wrapper from some ops description protobuf."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import six
+import tensorflow as tf
+
+from tensorflow.core.framework import types_pb2
+from tensorflow.python.framework import c_api_util
+
+flags = tf.flags
+FLAGS = flags.FLAGS
+
+flags.DEFINE_string(
+  'api_def_path',
+  None,
+  'path to the api_def directory, e.g. tensorflow/core/api_def/base_api')
+
+flags.DEFINE_string(
+  'output_path',
+  None,
+  'path for the generated swift file')
+
+_WARNING = """// !!! THIS CODE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND !!!
+//
+"""
+
+_HEADER = """// Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+//
+// 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.
+
+"""
+
+_OUTPUT_FILE = 'RawOpsGenerated.swift'
+_RENAMED_KEYWORDS = {
+  '': 'empty',
+  'in': 'in_',
+  'var': 'var_',
+  'where': 'where_',
+  'if': 'if_',
+  'for': 'for_',
+  'while': 'while_',
+  'switch': 'switch_',
+  'protocol': 'protocol_',
+  'init': 'init_'}
+
+_TYPE_PROTOCOLS = [
+  (set(), 'TensorFlowScalar'),
+  ({types_pb2.DT_UINT8,
+    types_pb2.DT_UINT16,
+    types_pb2.DT_UINT32,
+    types_pb2.DT_UINT64}, 'UnsignedInteger & TensorFlowScalar'),
+  ({types_pb2.DT_UINT8,
+    types_pb2.DT_UINT16,
+    types_pb2.DT_UINT32,
+    types_pb2.DT_UINT64,
+    types_pb2.DT_INT8,
+    types_pb2.DT_INT16,
+    types_pb2.DT_INT32,
+    types_pb2.DT_INT64}, 'BinaryInteger & TensorFlowScalar'),
+  ({types_pb2.DT_FLOAT,
+    types_pb2.DT_DOUBLE,
+    types_pb2.DT_HALF,
+    types_pb2.DT_BFLOAT16}, 'FloatingPoint & TensorFlowScalar'),
+  ({types_pb2.DT_UINT8,
+    types_pb2.DT_UINT16,
+    types_pb2.DT_UINT32,
+    types_pb2.DT_UINT64,
+    types_pb2.DT_INT8,
+    types_pb2.DT_INT16,
+    types_pb2.DT_INT32,
+    types_pb2.DT_INT64,
+    types_pb2.DT_FLOAT,
+    types_pb2.DT_DOUBLE,
+    types_pb2.DT_HALF,
+    types_pb2.DT_BFLOAT16}, 'Numeric & TensorFlowScalar')]
+
+_SWIFTIFIED_TYPES = {
+  types_pb2.DT_FLOAT: 'Float',
+  types_pb2.DT_DOUBLE: 'Double',
+  types_pb2.DT_INT32: 'Int32',
+  types_pb2.DT_UINT8: 'UInt8',
+  types_pb2.DT_INT16: 'Int16',
+  types_pb2.DT_INT8: 'Int8',
+  types_pb2.DT_INT64: 'Int64',
+  types_pb2.DT_BOOL: 'Bool',
+  types_pb2.DT_UINT16: 'UInt16',
+  types_pb2.DT_UINT32: 'UInt32',
+  types_pb2.DT_UINT64: 'UInt64'}
+
+_SWIFTIFIED_ATTR_TYPES = {
+  'int': 'Int64',
+  'float': 'Double',
+  'bool': 'Bool',
+  'string': 'String',
+  'type': 'TensorDataType',
+  'shape': 'TensorShape?',
+  'list(int)': '[Int32]',
+  'list(float)': '[Double]',
+  'list(bool)': '[Bool]',
+  'list(string)': '[String]',
+  'list(type)': '[TensorDataType]',
+  'list(shape)': '[TensorShape?]'}
+
+_OMITTED_PARAMETER_NAMES = {
+  'x', 'y', 'a', 'b', 'input', 'tensor', 'values'}
+
+_START_COMMENT = '///'
+
+
+class UnableToGenerateCodeError(Exception):
+  def __init__(self, details):
+    self.details = details
+    super(UnableToGenerateCodeError, self).__init__()
+
+  def __str__(self):
+    return self.details
+
+
+class Op(object):
+  def __init__(self, op_def, api_def, enum_store, string_valued=False):
+    self.op_def = op_def
+    self.api_def = api_def
+    self.enum_store = enum_store
+    self.string_valued = string_valued
+    self.inferred_counts = dict()
+
+    # Collect all the input and output arguments.
+    self.input_args = [
+      Argument(arg_def, op=self)
+      for arg_def in self.op_def.input_arg]
+    self.output_args = [
+      Argument(arg_def, op=self)
+      for arg_def in self.op_def.output_arg]
+
+    # Collect all attributes.
+    self.attrs = [
+      Attribute(attr, op=self)
+      for attr in op_def.attr]
+    self.type_attrs = [
+      attr for attr in self.attrs
+      if attr.is_type_attr]
+
+  def swift_function(self):
+    return '''
+{documentation}@inlinable @inline(__always)
+public static func {name}{generics}({input_args}
+){return_type} {{
+  {body}
+}}'''.format(
+      documentation=self._swift_documentation(),
+      name=self._swift_name(),
+      generics=self._swift_generics(),
+      input_args=self._swift_input_args(),
+      return_type=self._swift_return_type(),
+      body=self._swift_body())
+
+  def _swift_documentation(self):
+    def comment_block(text, indent_level):
+      """Returns a commented block of text with some specified indentation."""
+      def indent(line_index):
+        if indent_level == 0:
+          return ''
+        if line_index:
+          return '    ' * indent_level
+        return '    ' * (indent_level - 1) + '- '
+
+      return ''.join([
+        (_START_COMMENT + ' ' + indent(line_index) + line + '\n'
+         if line else _START_COMMENT + '\n')
+        for line_index, line in enumerate(text.split('\n'))
+      ])
+
+    def append_list(doc, args, arg_type):
+      """Returns the documentation for lists of inputs/outputs/attributes."""
+      args = [arg for arg in args if arg.description]
+      if len(args) == 1:
+        block = '%s %s: %s' % (arg_type, args[0].name, args[0].description)
+        doc += _START_COMMENT + '\n'
+        doc += comment_block(block, indent_level=1)
+      elif len(args) > 1:
+        doc += '%s\n%s - %ss:\n' % (_START_COMMENT, _START_COMMENT, arg_type)
+        for arg in args:
+          block = '%s: %s' % (arg.name, arg.description)
+          doc += comment_block(block, indent_level=2)
+      return doc
+
+    doc = ''
+    if self.api_def.summary:
+      doc = comment_block(self.api_def.summary, indent_level=0)
+    if self.api_def.description:
+      doc += _START_COMMENT + '\n'
+      doc += comment_block(self.api_def.description, indent_level=0)
+    doc = append_list(doc, self.api_def.in_arg, 'Parameter')
+    doc = append_list(doc, self.api_def.attr, 'Attr')
+    doc = append_list(doc, self.api_def.out_arg, 'Output')
+    if doc and not doc.endswith('\n'):
+      doc = doc + '\n'
+    return doc
+
+  def _swift_name(self):
+    return swift_compatible_identifier(
+      self.op_def.name[0].lower() + self.op_def.name[1:])
+
+  def _swift_generics(self):
+    constraints = [
+      attr.generic_constraints(self.string_valued)
+      for attr in self.attrs]
+    constraints = [c for c in constraints if c is not None]
+    if len(constraints) == 1:
+      return '<' + ', '.join(constraints) + '>'
+    if len(constraints) > 1:
+      return '<\n    ' + ',\n    '.join(constraints) + '\n>'
+    return ''
+
+  def _swift_input_args(self):
+    args = ''
+    for arg in self.input_args:
+      args += '\n    %s: %s,' % (arg.swift_arg_name, str(arg.swift_type(self.string_valued)))
+    for attr in self.attrs:
+      if not attr.is_inferred_type_attr and not attr.is_inferred_number_attr:
+        args += '\n    %s: %s%s,' % (attr.swift_arg_name, attr.swift_type, attr.swift_default)
+    if args != '':
+      args = args[:-1]
+    return args
+
+  def _swift_return_type(self):
+    return_type = ''
+    if len(self.output_args) == 1:
+      return_type = ' -> ' + str(self.output_args[0].swift_type(self.string_valued))
+    elif len(self.output_args) > 1:
+      named_types = [
+        arg.swift_name + ': ' + str(arg.swift_type(self.string_valued))
+        for arg in self.output_args]
+      return_type = ' -> (' + ', '.join(named_types) + ')'
+    return return_type
+
+  def _swift_body(self):
+    setters = []
+    for attr in self.attrs:
+      setters.append(attr.swift_setter(self.string_valued))
+    for arg in self.input_args:
+      setters.append(arg.swift_setter())
+    counts = ['Int({})'.format(arg.swift_count) for arg in self.output_args]
+    if len(self.output_args) == 0:
+      body = 'let nOutputs = 0'
+    else:
+      body = 'let nOutputs = {}'.format(' + '.join(counts))
+    body += '\n    let op = makeOp("{}", nOutputs)\n    '.format(self.op_def.name)
+    body += '\n    '.join(setters)
+    if len(self.output_args) == 0:
+      return body + '\n    op.execute()'
+    body += '\n    return op.execute({})'.format(', '.join(counts))
+    return body
+
+
+class Argument(object):
+  def __init__(self, arg_def, op):
+    self.arg_def = arg_def
+    self.op = op
+    self.is_list = arg_def.number_attr is not '' \
+                   or arg_def.type_list_attr is not ''
+
+  @property
+  def name(self):
+    return self.arg_def.name
+
+  @property
+  def swift_name(self):
+    return swift_compatible_identifier(
+      self.name[0].lower() + self.name[1:])
+
+  @property
+  def swift_arg_name(self):
+    name = self.swift_name
+    if name in _OMITTED_PARAMETER_NAMES:
+      name = '_ ' + name
+    return name
+
+  def swift_type(self, string_valued=False):
+    return self.type.swift_type(
+      string_valued=self.allows_string and string_valued)
+
+  def swift_setter(self):
+    if self.is_list:
+      return 'op.addInputList({})'.format(self.swift_name)
+    else:
+      return 'op.addInput({})'.format(self.swift_name)
+
+  @property
+  def swift_count(self):
+    number_attr = self.arg_def.number_attr
+    if number_attr and number_attr in self.op.inferred_counts:
+      return self.op.inferred_counts[number_attr]
+    if self.arg_def.type_list_attr:
+      return self.op.inferred_counts[self.arg_def.type_list_attr]
+    return '1'
+
+  @property
+  def type(self):
+    number = self.arg_def.number_attr
+    if self.arg_def.type_attr:
+      type_attr = next(
+        attr for attr in self.op.type_attrs
+        if attr.name == self.arg_def.type_attr)
+      return Type('Tensor', base_type=type_attr.swift_name, number=number)
+    if self.arg_def.type_list_attr:
+      type_attr = next(
+        attr for attr in self.op.type_attrs
+        if attr.name == self.arg_def.type_list_attr)
+      # There are never any numbered type lists.
+      return Type(type_attr.swift_name)
+    if self.arg_def.type in _SWIFTIFIED_TYPES:
+      base_type = _SWIFTIFIED_TYPES[self.arg_def.type]
+      return Type('Tensor', base_type=base_type, number=number)
+    if self.arg_def.type == types_pb2.DT_STRING:
+      return Type('Tensor', base_type='String', number=number)
+    if self.arg_def.type == types_pb2.DT_RESOURCE:
+      return Type('ResourceHandle', number=number)
+    if self.arg_def.type == types_pb2.DT_VARIANT:
+      return Type('VariantHandle', number=number)
+    raise UnableToGenerateCodeError(
+      'Unsupported type for argument "%s".' % self.name)
+
+  @property
+  def allows_string(self):
+    if self.arg_def.type_attr:
+      type_attr = next(
+        attr for attr in self.op.type_attrs
+        if attr.name == self.arg_def.type_attr)
+      return types_pb2.DT_STRING in type_attr.attr_def.allowed_values.list.type
+    return False
+
+
+class Type(object):
+  def __init__(self, kind, base_type=None, number=None):
+    self.kind = kind
+    self.base_type = base_type
+    self.number = number
+
+  @property
+  def count(self):
+    return self.number if self.number else 1
+
+  def swift_type(self, string_valued=False):
+    if self.kind == 'Tensor':
+      if self.base_type == 'String' or string_valued:
+        name = 'StringTensor'
+      else:
+        name = 'Tensor<' + self.base_type + '>'
+    elif self.kind == 'TensorHandle':
+      name = 'TensorHandle<' + self.base_type + '>'
+    elif self.kind == 'ResourceHandle':
+      name = 'ResourceHandle'
+    elif self.kind == 'VariantHandle':
+      name = 'VariantHandle'
+    else:
+      name = self.kind
+    return ('[%s]' % name) if self.number else name
+
+
+class Attribute(object):
+  """Represents information extracted from op `type` and `list(type)` attributes."""
+
+  def __init__(self, attr_def, op):
+    self.attr_def = attr_def
+    self.op = op
+    self.is_type_attr = attr_def.type in ['type', 'list(type)']
+
+    # Check whether the value of this attribute can be
+    # inferred automatically (this only applies to
+    # type-valued attributes).
+    input_args = list(op.op_def.input_arg)
+    output_args = list(op.op_def.output_arg)
+    input_arg_type_attrs = set(
+      [arg.type_attr for arg in input_args] +
+      [arg.type_list_attr for arg in input_args])
+    output_arg_type_attrs = set(
+      [arg.type_attr for arg in output_args] +
+      [arg.type_list_attr for arg in output_args])
+    arg_type_attrs = input_arg_type_attrs.union(output_arg_type_attrs)
+    self.is_inferred_type_attr = attr_def.name in arg_type_attrs
+    self.is_output_type_attr = attr_def.name in output_arg_type_attrs
+    self.is_func_attr = self.attr_def.type == 'func'
+
+    # We use this for obtaining the `_typeList` property.
+    self.input_arg = None
+    self.is_inferred_number_attr = False
+    for arg in self.op.input_args:
+      if self.attr_def.name in [arg.arg_def.type_attr,
+                                arg.arg_def.type_list_attr] or \
+         self.attr_def.name == arg.arg_def.number_attr:
+        self.input_arg = arg
+        self.is_inferred_number_attr = True
+        break
+
+    # The following properties are only relevant for
+    # non-inferred-type-valued attributes.
+    self._swift_type = ''
+    self._use_enum = False
+    if not self.is_inferred_type_attr and not self.is_func_attr:
+      if self.attr_def.type not in _SWIFTIFIED_ATTR_TYPES:
+        raise UnableToGenerateCodeError(
+          'Unsupported type for attribute "%s".'
+          % self.attr_def.name)
+
+      # Get the arg type.
+      self._swift_type = _SWIFTIFIED_ATTR_TYPES[self.attr_def.type]
+
+      # Check if the arg is an enum type.
+      self._use_enum = False
+      if self.attr_def.type == 'string':
+        allowed_values = tuple(sorted(self.attr_def.allowed_values.list.s))
+        if allowed_values:
+          self._swift_type = self.op.enum_store.maybe_add(
+            allowed_values, self.attr_def.name)
+          self._use_enum = True
+    if self.is_func_attr:
+      input_type = self.swift_name.capitalize() + 'In'
+      output_type = self.swift_name.capitalize() + 'Out'
+      self._swift_type = '({}) -> {}'.format(input_type, output_type)
+
+  @property
+  def name(self):
+    return self.attr_def.name
+
+  @property
+  def swift_name(self):
+    if self.is_inferred_type_attr:
+      return swift_compatible_identifier(
+        self.name, capitalize=True)
+    return swift_compatible_identifier(
+      self.name[0].lower() + self.name[1:])
+
+  @property
+  def swift_arg_name(self):
+    name = self.swift_name
+    if name in _OMITTED_PARAMETER_NAMES:
+      name = '_ ' + name
+    return name
+
+  @property
+  def swift_type(self):
+    return self._swift_type
+
+  @property
+  def swift_default(self):
+    def swift_float(f):
+      if f == float('inf'): return 'Double.infinity'
+      if f == float('-inf'): return '-Double.infinity'
+      return '%g' % f
+
+    if not self.is_inferred_type_attr and self.attr_def.default_value:
+      default_value = self.attr_def.default_value
+      if default_value.HasField('b'):
+        default_value = str(default_value.b).lower()
+      elif default_value.HasField('i'):
+        default_value = str(default_value.i)
+      elif default_value.HasField('f'):
+        default_value = swift_float(default_value.f)
+      elif default_value.HasField('s') and default_value.s:
+        s = str(default_value.s, encoding='utf-8')
+        default_value = '.' + swift_compatible_identifier(s.lower()) \
+          if self._use_enum else '"' + s + '"'
+      elif default_value.HasField('list'):
+        if default_value.list.i:
+          default_values = [str(s) for s in default_value.list.i]
+          default_value = '[' + ', '.join(default_values) + ']'
+        elif default_value.list.f:
+          default_values = [swift_float(s) for s in default_value.list.f]
+          default_value = '[' + ', '.join(default_values) + ']'
+        else:
+          default_value = None
+      else:
+        default_value = None
+      if default_value is not None:
+        default_value = default_value.replace("\t", "\\t")
+        return ' = ' + default_value
+    return ''
+
+  def swift_setter(self, string_valued=False):
+    # Inferred-type-valued attributes.
+    if self.is_inferred_type_attr:
+      name = self.swift_name
+      if self.input_arg is not None:
+        name = self.input_arg.swift_name
+      if self.attr_def.type == 'list(type)' or self.is_inferred_number_attr:
+        self.op.inferred_counts[self.name] = name + '._typeList.count'
+      if self.attr_def.type == 'list(type)':
+        return 'op.updateAttribute("{}", {}._typeList)'.format(self.name, name)
+      if string_valued and self.allows_string:
+        return 'op.updateAttribute("{}", TensorDataType(TF_STRING))'.format(self.name)
+      return 'op.updateAttribute("{}", {}.tensorFlowDataType)'.format(self.name, self.swift_name)
+
+    if self.is_inferred_number_attr:
+      # The following is used for inferring the lengths of output lists.
+      self.op.inferred_counts[self.name] = self.input_arg.swift_name + '.count'
+      return 'op.updateAttribute("{}", {}.count)'.format(self.name, self.input_arg.swift_name)
+    
+    if self.attr_def.type == 'int':
+      # The following is used for inferring the lengths of output lists.
+      self.op.inferred_counts[self.name] = self.swift_name
+
+    # Remaining attributes.
+    value = self.swift_name + '.cName' if self._use_enum else self.swift_name
+    return 'op.updateAttribute("{}", {})'.format(self.name, value)
+
+  def generic_constraints(self, string_valued):
+    # We use this for obtaining the `_typeList` property.
+    input_arg = None
+    if self.attr_def.type == 'list(type)':
+      for arg in self.op.input_args:
+        if self.attr_def.name in [arg.arg_def.type_attr,
+                                  arg.arg_def.type_list_attr]:
+          input_arg = arg
+          break
+    if self.is_func_attr:
+      input_type = self.swift_name.capitalize() + 'In'
+      output_type = self.swift_name.capitalize() + 'Out'
+      return '{}: TensorGroup,\n    {}: TensorGroup'.format(
+        input_type, output_type)
+    if not self.is_inferred_type_attr:
+      return None
+    protocol = None
+    if self.attr_def.type == 'list(type)' and input_arg is None:
+      protocol = 'TensorGroup'
+    elif self.attr_def.type == 'list(type)':
+      protocol = 'TensorArrayProtocol'
+    elif self.attr_def.type == 'type':
+      if string_valued and self.allows_string:
+        return None
+      protocol = 'TensorFlowScalar'
+      allowed_types = set(self.attr_def.allowed_values.list.type)
+      allowed_types &= set(_SWIFTIFIED_TYPES.keys())
+      for types, protocol_name in _TYPE_PROTOCOLS:
+        if allowed_types.issubset(types):
+          protocol = protocol_name
+          break
+    if protocol is not None:
+      return self.swift_name + ': ' + protocol
+    return None
+
+  @property
+  def allows_string(self):
+    return types_pb2.DT_STRING in self.attr_def.allowed_values.list.type
+
+
+def swift_compatible_identifier(s, capitalize=False):
+  """Transforms an identifier to be more swift idiomatic."""
+  if s in _RENAMED_KEYWORDS:
+    return _RENAMED_KEYWORDS[s]
+  if capitalize:
+    s = s.capitalize()
+  without_underscores = []
+  capitalize_next_char = False
+  for c in s:
+    if c == '-' or c == '_' or c == '(' or c == ')':
+      capitalize_next_char = True
+    elif capitalize_next_char:
+      capitalize_next_char = False
+      without_underscores.append(c.upper())
+    else:
+      without_underscores.append(c)
+  return ''.join(without_underscores)
+
+
+class EnumStore(object):
+  """Stores details on string attributes represented as swift enums."""
+
+  def __init__(self):
+    self._entries = {}
+    self._type_names = set()
+    self._counter = 1
+
+  def enum_codes(self):
+    """Generates the swift code for enums."""
+    codes = []
+    entries = list(six.iteritems(self._entries))
+    for allowed_values, type_name in sorted(entries, key=lambda x: x[1]):
+      allowed_values = [str(a, encoding='utf-8') for a in allowed_values]
+      codes.append(
+          # FIXME: Re-add `@_frozen` after SR-9739 is resolved.
+          # https://bugs.swift.org/browse/SR-9739
+          # '@_frozen\n' +
+          '// @_frozen // SR-9739\n' +
+          'public enum {} {{\n'.format(type_name) +
+          '\n'.join(['    case {}'.format(
+            swift_compatible_identifier(a.lower()))
+            for a in allowed_values]) +
+          '\n\n' +
+          '    @inlinable\n' +
+          '    var cName: String {\n' +
+          '        @inline(__always)\n' +
+          '        get {\n' +
+          '            switch self {\n' +
+          '\n'.join(['            case .{}: return "{}"'.format(
+            swift_compatible_identifier(a.lower()), a)
+            for a in allowed_values]) +
+          '\n' +
+          '            }\n' +
+          '        }\n' +
+          '    }\n' +
+          '}')
+    return codes
+
+  def maybe_add(self, allowed_values, attr_def_name):
+    if allowed_values in self._entries:
+      return self._entries[allowed_values]
+    type_name = swift_compatible_identifier(attr_def_name, capitalize=True)
+    while type_name in self._type_names:
+      type_name += str(self._counter)
+      self._counter += 1
+    self._type_names.add(type_name)
+    self._entries[allowed_values] = type_name
+    return type_name
+
+
+def main(argv):
+  del argv  # Unused.
+  if FLAGS.output_path is None:
+    raise ValueError('No output_path has been set')
+
+  api_def_map = c_api_util.ApiDefMap()
+
+  op_codes = []
+  enum_store = EnumStore()
+  op_names = api_def_map.op_names()
+  if FLAGS.api_def_path is not None:
+    for op_name in op_names:
+      path = os.path.join(FLAGS.api_def_path, 'api_def_%s.pbtxt' % op_name)
+      if not tf.gfile.Exists(path):
+        continue
+      with tf.gfile.Open(path, 'r') as fobj:
+        data = fobj.read()
+      try:
+        api_def_map.put_api_def(data)
+      except Exception as e:
+        print('Cannot load api def for %s: %s' % (op_name, str(e)))
+
+  num_generated = 0
+  for op_name in sorted(op_names):
+    try:
+      if op_name[0] == '_': continue
+      op_def = api_def_map.get_op_def(op_name)
+      if any(a.is_ref for a in op_def.input_arg):
+        raise UnableToGenerateCodeError('has ref-valued input')
+      if any(a.is_ref for a in op_def.output_arg):
+        raise UnableToGenerateCodeError('has ref-valued output')
+      api_def = api_def_map.get_api_def(bytes(op_name, 'utf8'))
+
+      # It would be nicer to handle `StringTensor` in a more
+      # general way by having `String` conform to `TensorFlowScalar`.
+      default_op = Op(op_def, api_def, enum_store, string_valued=False)
+      string_valued_op = Op(op_def, api_def, enum_store, string_valued=True)
+      default_code = default_op.swift_function()
+      string_valued_code = string_valued_op.swift_function()
+      op_codes.append(default_code)
+      if string_valued_code != default_code:
+        op_codes.append(string_valued_code)
+      num_generated += 1
+    except UnableToGenerateCodeError as e:
+      print('Cannot generate code for %s: %s' % (op_name, e.details))
+  print('Generated code for %d/%d ops.' % (num_generated, len(op_names)))
+
+  version_codes = [
+      'static let generatedTensorFlowVersion = "%s"' % tf.__version__,
+      'static let generatedTensorFlowGitVersion = "%s"' % tf.__git_version__]
+
+  swift_code = (
+      _WARNING +
+      _HEADER +
+      'import CTensorFlow\n\n' +
+      '@inlinable @inline(__always)\n' +
+      'func makeOp(_ name: String, _ nOutputs: Int) -> TFTensorOperation {\n' +
+      '    _ExecutionContext.makeOp(name, nOutputs)\n' +
+      '}\n'+
+      '\npublic enum Raw {\n\n' +
+      '\n'.join(version_codes) +
+      '\n\n' +
+      '\n\n'.join(enum_store.enum_codes()) +
+      '\n\n' +
+      '\n'.join(op_codes) +
+      '\n\n}\n')
+  with tf.gfile.Open(FLAGS.output_path, 'w') as f:
+    f.write(swift_code)
+
+
+if __name__ == '__main__':
+  tf.app.run(main)
diff --git a/clone_tensorflow_bindings.sh b/clone_tensorflow_bindings.sh
deleted file mode 100755
index 625a2a2c6..000000000
--- a/clone_tensorflow_bindings.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/bash
-
-git clone git@github.com:tensorflow/swift-bindings.git Sources/TensorFlow/Bindings

From b900f8f8bd73d5aaf300ff90d376f0887e61de42 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Tue, 28 May 2019 21:56:04 -0400
Subject: [PATCH 53/55] Fixed a couple of tests.

---
 Tests/TensorFlowTests/OperatorTests/MathTests.swift | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Tests/TensorFlowTests/OperatorTests/MathTests.swift b/Tests/TensorFlowTests/OperatorTests/MathTests.swift
index 327c7de08..2a208b258 100644
--- a/Tests/TensorFlowTests/OperatorTests/MathTests.swift
+++ b/Tests/TensorFlowTests/OperatorTests/MathTests.swift
@@ -88,8 +88,8 @@ final class MathOperatorTests: XCTestCase {
         let y = tanh(x)
         let array = y.array
         XCTAssertEqual([2], array.shape)
-        XCTAssertEqual(0.833655, Double(array.scalars[0]))
-        XCTAssertEqual(0.833655, Double(array.scalars[1]))
+        XCTAssertEqual(0.833655, Double(array.scalars[0]), accuracy: 0.0001)
+        XCTAssertEqual(0.833655, Double(array.scalars[1]), accuracy: 0.0001)
     }
 
     func testStandardDeviation() {

From cc9cf86d7aa5cb2175ebba12c8410917b8e55fdd Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Tue, 28 May 2019 23:23:23 -0400
Subject: [PATCH 54/55] Minor edits.

---
 Sources/TensorFlow/Core/Runtime.swift | 44 +++++++++++++--------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/Sources/TensorFlow/Core/Runtime.swift b/Sources/TensorFlow/Core/Runtime.swift
index b80ae90e8..75351df6d 100644
--- a/Sources/TensorFlow/Core/Runtime.swift
+++ b/Sources/TensorFlow/Core/Runtime.swift
@@ -138,7 +138,7 @@ internal class TraceContext {
         }
 
         let traceeInputCount = symbolicInputs.count
-        // Append concrete tensors created within the tracee as symbolic inputs to the generated 
+        // Append concrete tensors created within the tracee as symbolic inputs to the generated
         // trace graph function.
         additionalInputTensorCount = TFE_FinalizeInputTensorsFromTraceContext(cTraceContext)
         for i in 0..<additionalInputTensorCount {
@@ -180,12 +180,9 @@ internal class TraceContext {
         checkOk(status)
     }
 
-    /// Execute the trace graph function, and return the list of output tensors from the trace
+    /// Execute the trace graph function, and return the list of output tensors from the trace 
     /// execution. These output tensors are owned by the caller.
-    func execute(
-        traceeInputs: [_AnyTensorHandle],
-        useXLA: Bool = false
-    ) -> [CTensorHandle] {
+    func execute(traceeInputs: [_AnyTensorHandle], useXLA: Bool = false) -> [CTensorHandle] {
         // We must be in the `notTracing` enum mode.
         internalConsistencyCheck(_RuntimeConfig.traceState.context == nil)
         internalConsistencyCheck(traceGraphFn != nil)
@@ -551,8 +548,7 @@ public final class _ExecutionContext {
     public let tensorFlowConfig: UnsafeMutablePointer<TF_Buffer>
 
     /// The TFE_Context object.
-    @usableFromInline
-    internal let eagerContext: CTFEContext
+    @usableFromInline let eagerContext: CTFEContext
 
     /// The status for checking TensorFlow errors.
     private let status: CTFStatus = TF_NewStatus()
@@ -791,8 +787,8 @@ private func _trace(
     in fn: ([CTensorHandle]) -> [CTensorHandle]
 ) -> TraceContext {
     debugLog("""
-            Tracing over a function with \(dtypes.count) inputs.
-            """)
+             Tracing over a function with \(dtypes.count) inputs.
+             """)
 
     // Verify that we are not already tracing.
     internalConsistencyCheck(_RuntimeConfig.traceState.context == nil,
@@ -820,9 +816,11 @@ private func _trace(
     return finalizeTraceFunction(opType)
 }
 
-private func _graphInternal<State: _TensorArrayProtocolEnhanced,
-                            Data: TensorGroup,
-                            Result: TensorGroup>(
+private func _graphInternal<
+    State: _TensorArrayProtocolEnhanced,
+    Data: TensorGroup,
+    Result: TensorGroup
+>(
     with state: State,
     in fn: (State, Data) -> (State, Result?)
 ) -> (State, Data) -> (State, Result?) {
@@ -871,9 +869,7 @@ private func _graphInternal<State: _TensorArrayProtocolEnhanced,
 }
 
 // TODO: rename this to `graph` when it's ready for end users.
-public func _graph<State: _TensorArrayProtocolEnhanced,
-                   Data: TensorGroup,
-                   Result: TensorGroup>(
+public func _graph<State: _TensorArrayProtocolEnhanced, Data: TensorGroup, Result: TensorGroup>(
     with state: State,
     in fn: (State, Data) -> (State, Result)
 ) -> (State, Data) -> (State, Result) {
@@ -886,16 +882,16 @@ public func _graph<State: _TensorArrayProtocolEnhanced,
 }
 
 // TODO: rename this to `graph` when it's ready for end users.
-public func _graph<State : _TensorArrayProtocolEnhanced, Data : TensorGroup>(
+public func _graph<State: _TensorArrayProtocolEnhanced, Data: TensorGroup>(
     with state: State,
     in fn: (State, Data) -> State
 ) -> (State, Data) -> State {
-    let graphFunction: (State, Data) -> (State, TensorHandle<Float>?) =
+    let graphFunction: (State, Data) -> (State, Tensor<Float>?) =
         withoutActuallyEscaping(fn) { escapableFn in
             let wrappedFn = {
                 // The result argument needs to a type that conforms to TensorGroup.
-                // We are arbitrarily picking TensorHandle<Float> here.
-                (s: State, d: Data) -> (State, TensorHandle<Float>?) in
+                // We are arbitrarily picking Tensor<Float> here.
+                (s: State, d: Data) -> (State, Tensor<Float>?) in
                 (escapableFn(s, d), nil)
             }
             return _graphInternal(with: state, in: wrappedFn)
@@ -1095,7 +1091,7 @@ internal func dumpCTensorHandleContent(_ idx: Int, _ inputTensorHandle: CTensorH
 
 @inlinable
 @_cdecl("_swift_tfc_EagerExecute")
-internal func _TFCEagerExecute(
+func _TFCEagerExecute(
     _ op: CTFEOp,
     _ retvals: UnsafeMutablePointer<OpaquePointer?>,
     _ retvalCount: UnsafeMutablePointer<Int32>,
@@ -1118,7 +1114,6 @@ internal func _TFCEagerExecute(
     } else {
         debugLog("Executing eager op \(op).")
         TFE_Execute(op, retvals, retvalCount, status)
-        checkOk(status)
     }
 }
 
@@ -1170,6 +1165,11 @@ public protocol AnyTensor {
     var _tensorFlowDataType: TensorDataType { get }
 }
 
+extension Tensor: AnyTensor {
+    public var _rawTensorHandle: CTensorHandle { return handle._cTensorHandle }
+    public var _tensorFlowDataType: TensorDataType { return Scalar.tensorFlowDataType }
+}
+
 @usableFromInline
 func _TFCOpAddInputFromAnyTensors(_ op: CTFEOp, _ tensors: [AnyTensor], _ status: CTFStatus) {
     for tensor in tensors {

From e538b569533f5f661e560b51cfe50a9983f5d283 Mon Sep 17 00:00:00 2001
From: Anthony Platanios <e.a.platanios@gmail.com>
Date: Thu, 30 May 2019 02:37:31 -0400
Subject: [PATCH 55/55] Modified one test so that it passes.

---
 Tests/TensorFlowTests/LayerTests.swift | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/Tests/TensorFlowTests/LayerTests.swift b/Tests/TensorFlowTests/LayerTests.swift
index 47e157d16..8829baebe 100644
--- a/Tests/TensorFlowTests/LayerTests.swift
+++ b/Tests/TensorFlowTests/LayerTests.swift
@@ -201,15 +201,15 @@ final class LayerTests: XCTestCase {
                         [[ 0.055909205, 0.00035158166, 0.054020774,  0.09812111]]])
         let (𝛁rnn, _) = pullback(.init(inputs.map { SimpleRNNCell<Float>.State($0) }))
         XCTAssertEqual(𝛁rnn.cell.weight,
-                       [[          0.0,           0.0,           0.0,           0.0],
-                        [-0.0051169936,  0.0014167001,  0.0074189613,   0.017496519],
-                        [ -0.010233987,  0.0028334002,  0.0148379225,   0.034993038],
-                        [ -0.015350982,  0.0042501003,   0.022256885,    0.05248956],
-                        [          0.0,           0.0,           0.0,           0.0],
-                        [          0.0,           0.0,           0.0,           0.0],
-                        [          0.0,           0.0,           0.0,           0.0],
-                        [          0.0,           0.0,           0.0,           0.0]])
-        XCTAssertEqual(𝛁rnn.cell.bias, [-0.051169936,  0.014167001,   0.07418961,   0.17496519])
+                       [[         0.0,          0.0,          0.0,          0.0],
+                        [  0.02496884,   0.06694733,   0.07978788, -0.022378458],
+                        [  0.04993768,   0.13389467,   0.15957576, -0.044756915],
+                        [  0.07490652,   0.20084201,   0.23936366,  -0.06713537],
+                        [         0.0,          0.0,          0.0,          0.0],
+                        [         0.0,          0.0,          0.0,          0.0],
+                        [         0.0,          0.0,          0.0,          0.0],
+                        [         0.0,          0.0,          0.0,          0.0]])
+        XCTAssertEqual(𝛁rnn.cell.bias, [  0.2496884,  0.66947335,   0.7978788, -0.22378457])
     }
 
     static var allTests = [